Coverage Report

Created: 2025-06-13 06:43

/src/php-src/Zend/zend_vm_execute.h
Line
Count
Source (jump to first uncovered line)
1
/*
2
   +----------------------------------------------------------------------+
3
   | Zend Engine                                                          |
4
   +----------------------------------------------------------------------+
5
   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
6
   +----------------------------------------------------------------------+
7
   | This source file is subject to version 2.00 of the Zend 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
   | http://www.zend.com/license/2_00.txt.                                |
11
   | If you did not receive a copy of the Zend license and are unable to  |
12
   | obtain it through the world-wide-web, please send a note to          |
13
   | license@zend.com so we can mail you a copy immediately.              |
14
   +----------------------------------------------------------------------+
15
   | Authors: Andi Gutmans <andi@php.net>                                 |
16
   |          Zeev Suraski <zeev@php.net>                                 |
17
   |          Dmitry Stogov <dmitry@php.net>                              |
18
   +----------------------------------------------------------------------+
19
*/
20
21
#ifdef ZEND_WIN32
22
# pragma warning(disable : 4101)
23
# pragma warning(once : 6235)
24
# pragma warning(once : 6237)
25
# pragma warning(once : 6239)
26
# pragma warning(once : 6240)
27
# pragma warning(once : 6285)
28
# pragma warning(once : 6286)
29
# pragma warning(once : 6326)
30
#endif
31
static user_opcode_handler_t zend_user_opcode_handlers[256] = {
32
  (user_opcode_handler_t)NULL,
33
  (user_opcode_handler_t)NULL,
34
  (user_opcode_handler_t)NULL,
35
  (user_opcode_handler_t)NULL,
36
  (user_opcode_handler_t)NULL,
37
  (user_opcode_handler_t)NULL,
38
  (user_opcode_handler_t)NULL,
39
  (user_opcode_handler_t)NULL,
40
  (user_opcode_handler_t)NULL,
41
  (user_opcode_handler_t)NULL,
42
  (user_opcode_handler_t)NULL,
43
  (user_opcode_handler_t)NULL,
44
  (user_opcode_handler_t)NULL,
45
  (user_opcode_handler_t)NULL,
46
  (user_opcode_handler_t)NULL,
47
  (user_opcode_handler_t)NULL,
48
  (user_opcode_handler_t)NULL,
49
  (user_opcode_handler_t)NULL,
50
  (user_opcode_handler_t)NULL,
51
  (user_opcode_handler_t)NULL,
52
  (user_opcode_handler_t)NULL,
53
  (user_opcode_handler_t)NULL,
54
  (user_opcode_handler_t)NULL,
55
  (user_opcode_handler_t)NULL,
56
  (user_opcode_handler_t)NULL,
57
  (user_opcode_handler_t)NULL,
58
  (user_opcode_handler_t)NULL,
59
  (user_opcode_handler_t)NULL,
60
  (user_opcode_handler_t)NULL,
61
  (user_opcode_handler_t)NULL,
62
  (user_opcode_handler_t)NULL,
63
  (user_opcode_handler_t)NULL,
64
  (user_opcode_handler_t)NULL,
65
  (user_opcode_handler_t)NULL,
66
  (user_opcode_handler_t)NULL,
67
  (user_opcode_handler_t)NULL,
68
  (user_opcode_handler_t)NULL,
69
  (user_opcode_handler_t)NULL,
70
  (user_opcode_handler_t)NULL,
71
  (user_opcode_handler_t)NULL,
72
  (user_opcode_handler_t)NULL,
73
  (user_opcode_handler_t)NULL,
74
  (user_opcode_handler_t)NULL,
75
  (user_opcode_handler_t)NULL,
76
  (user_opcode_handler_t)NULL,
77
  (user_opcode_handler_t)NULL,
78
  (user_opcode_handler_t)NULL,
79
  (user_opcode_handler_t)NULL,
80
  (user_opcode_handler_t)NULL,
81
  (user_opcode_handler_t)NULL,
82
  (user_opcode_handler_t)NULL,
83
  (user_opcode_handler_t)NULL,
84
  (user_opcode_handler_t)NULL,
85
  (user_opcode_handler_t)NULL,
86
  (user_opcode_handler_t)NULL,
87
  (user_opcode_handler_t)NULL,
88
  (user_opcode_handler_t)NULL,
89
  (user_opcode_handler_t)NULL,
90
  (user_opcode_handler_t)NULL,
91
  (user_opcode_handler_t)NULL,
92
  (user_opcode_handler_t)NULL,
93
  (user_opcode_handler_t)NULL,
94
  (user_opcode_handler_t)NULL,
95
  (user_opcode_handler_t)NULL,
96
  (user_opcode_handler_t)NULL,
97
  (user_opcode_handler_t)NULL,
98
  (user_opcode_handler_t)NULL,
99
  (user_opcode_handler_t)NULL,
100
  (user_opcode_handler_t)NULL,
101
  (user_opcode_handler_t)NULL,
102
  (user_opcode_handler_t)NULL,
103
  (user_opcode_handler_t)NULL,
104
  (user_opcode_handler_t)NULL,
105
  (user_opcode_handler_t)NULL,
106
  (user_opcode_handler_t)NULL,
107
  (user_opcode_handler_t)NULL,
108
  (user_opcode_handler_t)NULL,
109
  (user_opcode_handler_t)NULL,
110
  (user_opcode_handler_t)NULL,
111
  (user_opcode_handler_t)NULL,
112
  (user_opcode_handler_t)NULL,
113
  (user_opcode_handler_t)NULL,
114
  (user_opcode_handler_t)NULL,
115
  (user_opcode_handler_t)NULL,
116
  (user_opcode_handler_t)NULL,
117
  (user_opcode_handler_t)NULL,
118
  (user_opcode_handler_t)NULL,
119
  (user_opcode_handler_t)NULL,
120
  (user_opcode_handler_t)NULL,
121
  (user_opcode_handler_t)NULL,
122
  (user_opcode_handler_t)NULL,
123
  (user_opcode_handler_t)NULL,
124
  (user_opcode_handler_t)NULL,
125
  (user_opcode_handler_t)NULL,
126
  (user_opcode_handler_t)NULL,
127
  (user_opcode_handler_t)NULL,
128
  (user_opcode_handler_t)NULL,
129
  (user_opcode_handler_t)NULL,
130
  (user_opcode_handler_t)NULL,
131
  (user_opcode_handler_t)NULL,
132
  (user_opcode_handler_t)NULL,
133
  (user_opcode_handler_t)NULL,
134
  (user_opcode_handler_t)NULL,
135
  (user_opcode_handler_t)NULL,
136
  (user_opcode_handler_t)NULL,
137
  (user_opcode_handler_t)NULL,
138
  (user_opcode_handler_t)NULL,
139
  (user_opcode_handler_t)NULL,
140
  (user_opcode_handler_t)NULL,
141
  (user_opcode_handler_t)NULL,
142
  (user_opcode_handler_t)NULL,
143
  (user_opcode_handler_t)NULL,
144
  (user_opcode_handler_t)NULL,
145
  (user_opcode_handler_t)NULL,
146
  (user_opcode_handler_t)NULL,
147
  (user_opcode_handler_t)NULL,
148
  (user_opcode_handler_t)NULL,
149
  (user_opcode_handler_t)NULL,
150
  (user_opcode_handler_t)NULL,
151
  (user_opcode_handler_t)NULL,
152
  (user_opcode_handler_t)NULL,
153
  (user_opcode_handler_t)NULL,
154
  (user_opcode_handler_t)NULL,
155
  (user_opcode_handler_t)NULL,
156
  (user_opcode_handler_t)NULL,
157
  (user_opcode_handler_t)NULL,
158
  (user_opcode_handler_t)NULL,
159
  (user_opcode_handler_t)NULL,
160
  (user_opcode_handler_t)NULL,
161
  (user_opcode_handler_t)NULL,
162
  (user_opcode_handler_t)NULL,
163
  (user_opcode_handler_t)NULL,
164
  (user_opcode_handler_t)NULL,
165
  (user_opcode_handler_t)NULL,
166
  (user_opcode_handler_t)NULL,
167
  (user_opcode_handler_t)NULL,
168
  (user_opcode_handler_t)NULL,
169
  (user_opcode_handler_t)NULL,
170
  (user_opcode_handler_t)NULL,
171
  (user_opcode_handler_t)NULL,
172
  (user_opcode_handler_t)NULL,
173
  (user_opcode_handler_t)NULL,
174
  (user_opcode_handler_t)NULL,
175
  (user_opcode_handler_t)NULL,
176
  (user_opcode_handler_t)NULL,
177
  (user_opcode_handler_t)NULL,
178
  (user_opcode_handler_t)NULL,
179
  (user_opcode_handler_t)NULL,
180
  (user_opcode_handler_t)NULL,
181
  (user_opcode_handler_t)NULL,
182
  (user_opcode_handler_t)NULL,
183
  (user_opcode_handler_t)NULL,
184
  (user_opcode_handler_t)NULL,
185
  (user_opcode_handler_t)NULL,
186
  (user_opcode_handler_t)NULL,
187
  (user_opcode_handler_t)NULL,
188
  (user_opcode_handler_t)NULL,
189
  (user_opcode_handler_t)NULL,
190
  (user_opcode_handler_t)NULL,
191
  (user_opcode_handler_t)NULL,
192
  (user_opcode_handler_t)NULL,
193
  (user_opcode_handler_t)NULL,
194
  (user_opcode_handler_t)NULL,
195
  (user_opcode_handler_t)NULL,
196
  (user_opcode_handler_t)NULL,
197
  (user_opcode_handler_t)NULL,
198
  (user_opcode_handler_t)NULL,
199
  (user_opcode_handler_t)NULL,
200
  (user_opcode_handler_t)NULL,
201
  (user_opcode_handler_t)NULL,
202
  (user_opcode_handler_t)NULL,
203
  (user_opcode_handler_t)NULL,
204
  (user_opcode_handler_t)NULL,
205
  (user_opcode_handler_t)NULL,
206
  (user_opcode_handler_t)NULL,
207
  (user_opcode_handler_t)NULL,
208
  (user_opcode_handler_t)NULL,
209
  (user_opcode_handler_t)NULL,
210
  (user_opcode_handler_t)NULL,
211
  (user_opcode_handler_t)NULL,
212
  (user_opcode_handler_t)NULL,
213
  (user_opcode_handler_t)NULL,
214
  (user_opcode_handler_t)NULL,
215
  (user_opcode_handler_t)NULL,
216
  (user_opcode_handler_t)NULL,
217
  (user_opcode_handler_t)NULL,
218
  (user_opcode_handler_t)NULL,
219
  (user_opcode_handler_t)NULL,
220
  (user_opcode_handler_t)NULL,
221
  (user_opcode_handler_t)NULL,
222
  (user_opcode_handler_t)NULL,
223
  (user_opcode_handler_t)NULL,
224
  (user_opcode_handler_t)NULL,
225
  (user_opcode_handler_t)NULL,
226
  (user_opcode_handler_t)NULL,
227
  (user_opcode_handler_t)NULL,
228
  (user_opcode_handler_t)NULL,
229
  (user_opcode_handler_t)NULL,
230
  (user_opcode_handler_t)NULL,
231
  (user_opcode_handler_t)NULL,
232
  (user_opcode_handler_t)NULL,
233
  (user_opcode_handler_t)NULL,
234
  (user_opcode_handler_t)NULL,
235
  (user_opcode_handler_t)NULL,
236
  (user_opcode_handler_t)NULL,
237
  (user_opcode_handler_t)NULL,
238
  (user_opcode_handler_t)NULL,
239
  (user_opcode_handler_t)NULL,
240
  (user_opcode_handler_t)NULL,
241
  (user_opcode_handler_t)NULL,
242
  (user_opcode_handler_t)NULL,
243
  (user_opcode_handler_t)NULL,
244
  (user_opcode_handler_t)NULL,
245
  (user_opcode_handler_t)NULL,
246
  (user_opcode_handler_t)NULL,
247
  (user_opcode_handler_t)NULL,
248
  (user_opcode_handler_t)NULL,
249
  (user_opcode_handler_t)NULL,
250
  (user_opcode_handler_t)NULL,
251
  (user_opcode_handler_t)NULL,
252
  (user_opcode_handler_t)NULL,
253
  (user_opcode_handler_t)NULL,
254
  (user_opcode_handler_t)NULL,
255
  (user_opcode_handler_t)NULL,
256
  (user_opcode_handler_t)NULL,
257
  (user_opcode_handler_t)NULL,
258
  (user_opcode_handler_t)NULL,
259
  (user_opcode_handler_t)NULL,
260
  (user_opcode_handler_t)NULL,
261
  (user_opcode_handler_t)NULL,
262
  (user_opcode_handler_t)NULL,
263
  (user_opcode_handler_t)NULL,
264
  (user_opcode_handler_t)NULL,
265
  (user_opcode_handler_t)NULL,
266
  (user_opcode_handler_t)NULL,
267
  (user_opcode_handler_t)NULL,
268
  (user_opcode_handler_t)NULL,
269
  (user_opcode_handler_t)NULL,
270
  (user_opcode_handler_t)NULL,
271
  (user_opcode_handler_t)NULL,
272
  (user_opcode_handler_t)NULL,
273
  (user_opcode_handler_t)NULL,
274
  (user_opcode_handler_t)NULL,
275
  (user_opcode_handler_t)NULL,
276
  (user_opcode_handler_t)NULL,
277
  (user_opcode_handler_t)NULL,
278
  (user_opcode_handler_t)NULL,
279
  (user_opcode_handler_t)NULL,
280
  (user_opcode_handler_t)NULL,
281
  (user_opcode_handler_t)NULL,
282
  (user_opcode_handler_t)NULL,
283
  (user_opcode_handler_t)NULL,
284
  (user_opcode_handler_t)NULL,
285
  (user_opcode_handler_t)NULL,
286
  (user_opcode_handler_t)NULL,
287
  (user_opcode_handler_t)NULL
288
};
289
290
static uint8_t zend_user_opcodes[256] = {0,
291
  1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
292
  17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
293
  33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,
294
  49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,
295
  65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,
296
  81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,
297
  97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
298
  113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,
299
  129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,
300
  145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,
301
  161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,
302
  177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,
303
  193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,
304
  209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,
305
  225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,
306
  241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
307
};
308
309
#include "Zend/zend_vm_opcodes.h"
310
311
9.19M
#define SPEC_START_MASK        0x0000ffff
312
9.19M
#define SPEC_EXTRA_MASK        0xfffc0000
313
9.23M
#define SPEC_RULE_OP1          0x00010000
314
9.20M
#define SPEC_RULE_OP2          0x00020000
315
593k
#define SPEC_RULE_OP_DATA      0x00040000
316
1.97M
#define SPEC_RULE_RETVAL       0x00080000
317
891k
#define SPEC_RULE_QUICK_ARG    0x00100000
318
541k
#define SPEC_RULE_SMART_BRANCH 0x00200000
319
7.80M
#define SPEC_RULE_COMMUTATIVE  0x00800000
320
540k
#define SPEC_RULE_ISSET        0x01000000
321
1.54M
#define SPEC_RULE_OBSERVER     0x02000000
322
323
static const uint32_t *zend_spec_handlers;
324
static const void * const *zend_opcode_handlers;
325
static int zend_handlers_count;
326
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
327
static const void * const * zend_opcode_handler_funcs;
328
static zend_op hybrid_halt_op;
329
#endif
330
#if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
331
static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op);
332
#endif
333
334
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
335
static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op* op);
336
#else
337
# define zend_vm_get_opcode_handler_func zend_vm_get_opcode_handler
338
#endif
339
340
#ifndef VM_TRACE
341
# define VM_TRACE(op)
342
#endif
343
#ifndef VM_TRACE_OP_END
344
# define VM_TRACE_OP_END(op)
345
#endif
346
#ifndef VM_TRACE_START
347
# define VM_TRACE_START()
348
#endif
349
#ifndef VM_TRACE_END
350
# define VM_TRACE_END()
351
#endif
352
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
353
# if defined(__GNUC__) && defined(__i386__)
354
#  define HYBRID_JIT_GUARD() __asm__ __volatile__ (""::: "ebx")
355
# elif defined(__GNUC__) && defined(__x86_64__)
356
#  define HYBRID_JIT_GUARD() __asm__ __volatile__ (""::: "rbx","r12","r13")
357
# elif defined(__GNUC__) && defined(__aarch64__)
358
#  define HYBRID_JIT_GUARD() __asm__ __volatile__ (""::: "x19","x20","x21","x22","x23","x24","x25","x26")
359
# else
360
#  define HYBRID_JIT_GUARD()
361
# endif
362
#define HYBRID_NEXT()     HYBRID_JIT_GUARD(); goto *(void**)(OPLINE->handler)
363
#define HYBRID_SWITCH()   HYBRID_NEXT();
364
#define HYBRID_CASE(op)   op ## _LABEL
365
#define HYBRID_BREAK()    HYBRID_NEXT()
366
#define HYBRID_DEFAULT    ZEND_NULL_LABEL
367
#endif
368
369
#ifdef ZEND_VM_FP_GLOBAL_REG
370
# define ZEND_OPCODE_HANDLER_ARGS void
371
# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU
372
# define ZEND_OPCODE_HANDLER_ARGS_EX
373
# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX
374
#else
375
# define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data, const zend_op *opline
376
3.76M
# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data, opline
377
# define ZEND_OPCODE_HANDLER_ARGS_EX ZEND_OPCODE_HANDLER_ARGS, 
378
# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX ZEND_OPCODE_HANDLER_ARGS_PASSTHRU, 
379
#endif
380
381
#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
382
# define ZEND_OPCODE_HANDLER_RET void
383
# define ZEND_VM_TAIL_CALL(call) call; return
384
# ifdef ZEND_VM_TAIL_CALL_DISPATCH
385
#  define ZEND_VM_CONTINUE()     ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); return
386
# else
387
#  define ZEND_VM_CONTINUE()     return
388
# endif
389
# if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
390
#  define ZEND_VM_RETURN()        opline = &hybrid_halt_op; return
391
#  define ZEND_VM_HOT             zend_always_inline ZEND_COLD ZEND_OPT_SIZE
392
#  define ZEND_VM_COLD            ZEND_COLD ZEND_OPT_SIZE
393
# else
394
#  define ZEND_VM_RETURN()        opline = NULL; return
395
#  define ZEND_VM_HOT
396
#  define ZEND_VM_COLD            ZEND_COLD ZEND_OPT_SIZE
397
# endif
398
#else
399
# define ZEND_OPCODE_HANDLER_RET const zend_op *
400
2.18M
# define ZEND_VM_TAIL_CALL(call) return call
401
17.3M
# define ZEND_VM_CONTINUE()      return opline
402
401k
# define ZEND_VM_RETURN()        return (const zend_op*)ZEND_VM_ENTER_BIT
403
# define ZEND_VM_HOT
404
# define ZEND_VM_COLD            ZEND_COLD ZEND_OPT_SIZE
405
#endif
406
407
typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_HANDLER_ARGS);
408
409
#ifdef ZEND_VM_IP_GLOBAL_REG
410
# define DCL_OPLINE
411
# define OPLINE opline
412
# define USE_OPLINE
413
# define LOAD_OPLINE() opline = EX(opline)
414
# define LOAD_OPLINE_EX()
415
# define LOAD_NEXT_OPLINE() opline = EX(opline) + 1
416
# define SAVE_OPLINE() EX(opline) = opline
417
# define SAVE_OPLINE_EX() SAVE_OPLINE()
418
#else
419
83.1k
# define DCL_OPLINE const zend_op *opline;
420
16.5M
# define OPLINE opline
421
# define USE_OPLINE
422
1.00M
# define LOAD_OPLINE() opline = EX(opline)
423
28.4k
# define LOAD_OPLINE_EX() opline = EX(opline)
424
25.0k
# define LOAD_NEXT_OPLINE() opline = EX(opline) + 1
425
12.2M
# define SAVE_OPLINE() EX(opline) = opline
426
# define SAVE_OPLINE_EX()
427
#endif
428
872k
#define HANDLE_EXCEPTION() ZEND_ASSERT(EG(exception)); LOAD_OPLINE(); ZEND_VM_CONTINUE()
429
3.64k
#define HANDLE_EXCEPTION_LEAVE() ZEND_ASSERT(EG(exception)); LOAD_OPLINE(); ZEND_VM_LEAVE()
430
#if defined(ZEND_VM_FP_GLOBAL_REG)
431
# define ZEND_VM_ENTER_EX()        ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE()
432
# define ZEND_VM_ENTER()           execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX()
433
# define ZEND_VM_LEAVE()           ZEND_VM_CONTINUE()
434
#elif defined(ZEND_VM_IP_GLOBAL_REG)
435
# define ZEND_VM_ENTER_EX()        return  1
436
# define ZEND_VM_ENTER()           opline = EG(current_execute_data)->opline; ZEND_VM_ENTER_EX()
437
# define ZEND_VM_LEAVE()           return  2
438
#else
439
573k
# define ZEND_VM_ENTER_BIT         1ULL
440
29.4k
# define ZEND_VM_ENTER_EX()        return (zend_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT)
441
1.02k
# define ZEND_VM_ENTER()           execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX()
442
30.3k
# define ZEND_VM_LEAVE()           return (zend_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT)
443
#endif
444
0
#define ZEND_VM_INTERRUPT()      ZEND_VM_TAIL_CALL(zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
445
0
#define ZEND_VM_LOOP_INTERRUPT() zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
446
0
#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler_func(opcode, opline))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
447
448
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS);
449
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS);
450
451
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
452
32.9k
{
453
32.9k
  USE_OPLINE
454
455
32.9k
  SAVE_OPLINE();
456
32.9k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
457
5.47k
    op_1 = ZVAL_UNDEFINED_OP1();
458
5.47k
  }
459
32.9k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
460
7.49k
    op_2 = ZVAL_UNDEFINED_OP2();
461
7.49k
  }
462
32.9k
  add_function(EX_VAR(opline->result.var), op_1, op_2);
463
32.9k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
464
11.4k
    zval_ptr_dtor_nogc(op_1);
465
11.4k
  }
466
32.9k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
467
11.3k
    zval_ptr_dtor_nogc(op_2);
468
11.3k
  }
469
32.9k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
470
32.9k
}
471
472
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
473
6.96k
{
474
6.96k
  USE_OPLINE
475
476
6.96k
  SAVE_OPLINE();
477
6.96k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
478
754
    op_1 = ZVAL_UNDEFINED_OP1();
479
754
  }
480
6.96k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
481
1.41k
    op_2 = ZVAL_UNDEFINED_OP2();
482
1.41k
  }
483
6.96k
  sub_function(EX_VAR(opline->result.var), op_1, op_2);
484
6.96k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
485
607
    zval_ptr_dtor_nogc(op_1);
486
607
  }
487
6.96k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
488
1.25k
    zval_ptr_dtor_nogc(op_2);
489
1.25k
  }
490
6.96k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
491
6.96k
}
492
493
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
494
41.5k
{
495
41.5k
  USE_OPLINE
496
497
41.5k
  SAVE_OPLINE();
498
41.5k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
499
27.2k
    op_1 = ZVAL_UNDEFINED_OP1();
500
27.2k
  }
501
41.5k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
502
1.15k
    op_2 = ZVAL_UNDEFINED_OP2();
503
1.15k
  }
504
41.5k
  mul_function(EX_VAR(opline->result.var), op_1, op_2);
505
41.5k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
506
3.91k
    zval_ptr_dtor_nogc(op_1);
507
3.91k
  }
508
41.5k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
509
1.15k
    zval_ptr_dtor_nogc(op_2);
510
1.15k
  }
511
41.5k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
512
41.5k
}
513
514
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
515
69
{
516
69
  USE_OPLINE
517
518
69
  SAVE_OPLINE();
519
69
  zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero");
520
69
  ZVAL_UNDEF(EX_VAR(opline->result.var));
521
69
  HANDLE_EXCEPTION();
522
69
}
523
524
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
525
19.1k
{
526
19.1k
  USE_OPLINE
527
528
19.1k
  SAVE_OPLINE();
529
19.1k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
530
889
    op_1 = ZVAL_UNDEFINED_OP1();
531
889
  }
532
19.1k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
533
8
    op_2 = ZVAL_UNDEFINED_OP2();
534
8
  }
535
19.1k
  mod_function(EX_VAR(opline->result.var), op_1, op_2);
536
19.1k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
537
193
    zval_ptr_dtor_nogc(op_1);
538
193
  }
539
19.1k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
540
857
    zval_ptr_dtor_nogc(op_2);
541
857
  }
542
19.1k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
543
19.1k
}
544
545
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
546
2.47k
{
547
2.47k
  USE_OPLINE
548
549
2.47k
  SAVE_OPLINE();
550
2.47k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
551
34
    op_1 = ZVAL_UNDEFINED_OP1();
552
34
  }
553
2.47k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
554
138
    op_2 = ZVAL_UNDEFINED_OP2();
555
138
  }
556
2.47k
  shift_left_function(EX_VAR(opline->result.var), op_1, op_2);
557
2.47k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
558
209
    zval_ptr_dtor_nogc(op_1);
559
209
  }
560
2.47k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
561
61
    zval_ptr_dtor_nogc(op_2);
562
61
  }
563
2.47k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
564
2.47k
}
565
566
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
567
495
{
568
495
  USE_OPLINE
569
570
495
  SAVE_OPLINE();
571
495
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
572
240
    op_1 = ZVAL_UNDEFINED_OP1();
573
240
  }
574
495
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
575
0
    op_2 = ZVAL_UNDEFINED_OP2();
576
0
  }
577
495
  shift_right_function(EX_VAR(opline->result.var), op_1, op_2);
578
495
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
579
14
    zval_ptr_dtor_nogc(op_1);
580
14
  }
581
495
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
582
326
    zval_ptr_dtor_nogc(op_2);
583
326
  }
584
495
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
585
495
}
586
587
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
588
240k
{
589
240k
  int ret;
590
240k
  USE_OPLINE
591
592
240k
  SAVE_OPLINE();
593
240k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
594
231k
    op_1 = ZVAL_UNDEFINED_OP1();
595
231k
  }
596
240k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
597
852
    op_2 = ZVAL_UNDEFINED_OP2();
598
852
  }
599
240k
  ret = zend_compare(op_1, op_2);
600
240k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
601
417
    zval_ptr_dtor_nogc(op_1);
602
417
  }
603
240k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
604
4.41k
    zval_ptr_dtor_nogc(op_2);
605
4.41k
  }
606
240k
  ZEND_VM_SMART_BRANCH(ret == 0, 1);
607
240k
}
608
609
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
610
20.6k
{
611
20.6k
  int ret;
612
20.6k
  USE_OPLINE
613
614
20.6k
  SAVE_OPLINE();
615
20.6k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
616
12.1k
    op_1 = ZVAL_UNDEFINED_OP1();
617
12.1k
  }
618
20.6k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
619
1.93k
    op_2 = ZVAL_UNDEFINED_OP2();
620
1.93k
  }
621
20.6k
  ret = zend_compare(op_1, op_2);
622
20.6k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
623
1.22k
    zval_ptr_dtor_nogc(op_1);
624
1.22k
  }
625
20.6k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
626
10.5k
    zval_ptr_dtor_nogc(op_2);
627
10.5k
  }
628
20.6k
  ZEND_VM_SMART_BRANCH(ret != 0, 1);
629
20.6k
}
630
631
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
632
42.8k
{
633
42.8k
  int ret;
634
42.8k
  USE_OPLINE
635
636
42.8k
  SAVE_OPLINE();
637
42.8k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
638
15.9k
    op_1 = ZVAL_UNDEFINED_OP1();
639
15.9k
  }
640
42.8k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
641
22.6k
    op_2 = ZVAL_UNDEFINED_OP2();
642
22.6k
  }
643
42.8k
  ret = zend_compare(op_1, op_2);
644
42.8k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
645
23.7k
    zval_ptr_dtor_nogc(op_1);
646
23.7k
  }
647
42.8k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
648
2.15k
    zval_ptr_dtor_nogc(op_2);
649
2.15k
  }
650
42.8k
  ZEND_VM_SMART_BRANCH(ret < 0, 1);
651
42.8k
}
652
653
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
654
29.0k
{
655
29.0k
  int ret;
656
29.0k
  USE_OPLINE
657
658
29.0k
  SAVE_OPLINE();
659
29.0k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
660
4.18k
    op_1 = ZVAL_UNDEFINED_OP1();
661
4.18k
  }
662
29.0k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
663
21.0k
    op_2 = ZVAL_UNDEFINED_OP2();
664
21.0k
  }
665
29.0k
  ret = zend_compare(op_1, op_2);
666
29.0k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
667
20.6k
    zval_ptr_dtor_nogc(op_1);
668
20.6k
  }
669
29.0k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
670
241
    zval_ptr_dtor_nogc(op_2);
671
241
  }
672
29.0k
  ZEND_VM_SMART_BRANCH(ret <= 0, 1);
673
29.0k
}
674
675
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
676
14.1k
{
677
14.1k
  USE_OPLINE
678
679
14.1k
  SAVE_OPLINE();
680
14.1k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
681
7
    op_1 = ZVAL_UNDEFINED_OP1();
682
7
  }
683
14.1k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
684
12
    op_2 = ZVAL_UNDEFINED_OP2();
685
12
  }
686
14.1k
  bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2);
687
14.1k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
688
12.6k
    zval_ptr_dtor_nogc(op_1);
689
12.6k
  }
690
14.1k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
691
1.64k
    zval_ptr_dtor_nogc(op_2);
692
1.64k
  }
693
14.1k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
694
14.1k
}
695
696
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
697
123k
{
698
123k
  USE_OPLINE
699
700
123k
  SAVE_OPLINE();
701
123k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
702
906
    op_1 = ZVAL_UNDEFINED_OP1();
703
906
  }
704
123k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
705
651
    op_2 = ZVAL_UNDEFINED_OP2();
706
651
  }
707
123k
  bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2);
708
123k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
709
58.8k
    zval_ptr_dtor_nogc(op_1);
710
58.8k
  }
711
123k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
712
117k
    zval_ptr_dtor_nogc(op_2);
713
117k
  }
714
123k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
715
123k
}
716
717
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
718
111k
{
719
111k
  USE_OPLINE
720
721
111k
  SAVE_OPLINE();
722
111k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
723
0
    op_1 = ZVAL_UNDEFINED_OP1();
724
0
  }
725
111k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
726
2
    op_2 = ZVAL_UNDEFINED_OP2();
727
2
  }
728
111k
  bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2);
729
111k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
730
79.9k
    zval_ptr_dtor_nogc(op_1);
731
79.9k
  }
732
111k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
733
68.9k
    zval_ptr_dtor_nogc(op_2);
734
68.9k
  }
735
111k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
736
111k
}
737
738
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1)
739
5.52k
{
740
5.52k
  USE_OPLINE
741
742
5.52k
  SAVE_OPLINE();
743
5.52k
  if (UNEXPECTED(Z_TYPE_P(op_1) == IS_UNDEF)) {
744
18
    op_1 = ZVAL_UNDEFINED_OP1();
745
18
  }
746
5.52k
  bitwise_not_function(EX_VAR(opline->result.var), op_1);
747
5.52k
  FREE_OP(opline->op1_type, opline->op1.var);
748
5.52k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
749
5.52k
}
750
751
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
752
105
{
753
105
  USE_OPLINE
754
755
105
  SAVE_OPLINE();
756
105
  zend_throw_error(NULL, "Using $this when not in object context");
757
105
  UNDEF_RESULT();
758
105
  HANDLE_EXCEPTION();
759
105
}
760
761
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
762
2.84k
{
763
2.84k
  USE_OPLINE
764
2.84k
  zval *function_name;
765
766
2.84k
  SAVE_OPLINE();
767
2.84k
  function_name = RT_CONSTANT(opline, opline->op2);
768
2.84k
  zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name));
769
2.84k
  HANDLE_EXCEPTION();
770
2.84k
}
771
772
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
773
90
{
774
  /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
775
776
90
  USE_OPLINE
777
90
  zval *prop, *value;
778
90
  zend_property_info *prop_info;
779
90
  zend_reference *ref;
780
781
90
  SAVE_OPLINE();
782
783
90
  prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC);
784
90
  if (UNEXPECTED(!prop)) {
785
7
    UNDEF_RESULT();
786
7
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
787
7
    HANDLE_EXCEPTION();
788
7
  }
789
790
83
  if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
791
83
   && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) {
792
10
    zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
793
10
    UNDEF_RESULT();
794
10
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
795
10
    HANDLE_EXCEPTION();
796
10
  }
797
798
73
  value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
799
800
73
  do {
801
73
    if (UNEXPECTED(Z_ISREF_P(prop))) {
802
12
      ref = Z_REF_P(prop);
803
12
      prop = Z_REFVAL_P(prop);
804
12
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
805
10
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
806
10
        break;
807
10
      }
808
12
    }
809
810
63
    if (ZEND_TYPE_IS_SET(prop_info->type)) {
811
      /* special case for typed properties */
812
61
      zend_binary_assign_op_typed_prop(prop_info, prop, value OPLINE_CC EXECUTE_DATA_CC);
813
61
    } else {
814
2
      zend_binary_op(prop, prop, value OPLINE_CC);
815
2
    }
816
63
  } while (0);
817
818
73
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
819
8
    ZVAL_COPY(EX_VAR(opline->result.var), prop);
820
8
  }
821
822
73
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
823
  /* assign_static_prop has two opcodes! */
824
73
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
825
73
}
826
827
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
828
81
{
829
81
  USE_OPLINE
830
81
  zval *prop;
831
81
  zend_property_info *prop_info;
832
833
81
  SAVE_OPLINE();
834
835
81
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC);
836
81
  if (UNEXPECTED(!prop)) {
837
2
    UNDEF_RESULT();
838
2
    HANDLE_EXCEPTION();
839
2
  }
840
841
79
  if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
842
79
   && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) {
843
22
    zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
844
22
    UNDEF_RESULT();
845
22
    HANDLE_EXCEPTION();
846
22
  }
847
848
57
  zend_pre_incdec_property_zval(prop,
849
57
    ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
850
851
57
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
852
57
}
853
854
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
855
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
856
845
{
857
845
  USE_OPLINE
858
845
  zval *prop;
859
845
  zend_property_info *prop_info;
860
861
845
  SAVE_OPLINE();
862
863
845
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC);
864
845
  if (UNEXPECTED(!prop)) {
865
31
    UNDEF_RESULT();
866
31
    HANDLE_EXCEPTION();
867
31
  }
868
869
814
  if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
870
814
   && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) {
871
0
    zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
872
0
    UNDEF_RESULT();
873
0
    HANDLE_EXCEPTION();
874
0
  }
875
876
814
  zend_post_incdec_property_zval(prop,
877
814
    ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
878
879
814
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
880
814
}
881
882
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
883
static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX int type)
884
4.27k
{
885
4.27k
  USE_OPLINE
886
4.27k
  zval *prop;
887
4.27k
  zend_property_info *prop_info;
888
889
4.27k
  SAVE_OPLINE();
890
891
4.27k
  prop = zend_fetch_static_property_address(
892
4.27k
    &prop_info, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type,
893
4.27k
    type == BP_VAR_W ? opline->extended_value : 0 OPLINE_CC EXECUTE_DATA_CC);
894
4.27k
  if (UNEXPECTED(!prop)) {
895
217
    ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS));
896
217
    prop = &EG(uninitialized_zval);
897
4.05k
  } else if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
898
4.05k
   && (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)
899
4.05k
   && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) {
900
40
    if (Z_TYPE_P(prop) == IS_OBJECT) {
901
10
      goto copy_deref;
902
30
    } else if (type != BP_VAR_UNSET || Z_TYPE_P(prop) != IS_UNDEF) {
903
20
      zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
904
20
    }
905
30
    prop = &EG(uninitialized_zval);
906
30
  }
907
908
4.26k
  if (type == BP_VAR_R || type == BP_VAR_IS) {
909
3.35k
copy_deref:
910
3.35k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
911
3.35k
  } else {
912
918
    ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
913
918
  }
914
4.27k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
915
4.27k
}
916
917
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
918
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
919
3.07k
{
920
3.07k
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R));
921
3.07k
}
922
923
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
924
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
925
775
{
926
775
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W));
927
775
}
928
929
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
930
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
931
0
{
932
0
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW));
933
0
}
934
935
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
936
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
937
292
{
938
292
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
939
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
940
292
  } else {
941
292
    ZEND_VM_TAIL_CALL(ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
942
292
  }
943
292
}
944
945
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
946
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
947
153
{
948
153
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET));
949
153
}
950
951
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
952
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
953
272
{
954
272
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS));
955
272
}
956
957
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
958
20
{
959
20
  USE_OPLINE
960
961
20
  SAVE_OPLINE();
962
20
  zend_throw_error(NULL, "Cannot use temporary expression in write context");
963
20
  FREE_OP(opline->op2_type, opline->op2.var);
964
20
  FREE_OP(opline->op1_type, opline->op1.var);
965
20
  ZVAL_UNDEF(EX_VAR(opline->result.var));
966
20
  HANDLE_EXCEPTION();
967
20
}
968
969
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
970
10
{
971
10
  USE_OPLINE
972
973
10
  SAVE_OPLINE();
974
10
  zend_throw_error(NULL, "Cannot use [] for reading");
975
10
  FREE_OP(opline->op2_type, opline->op2.var);
976
10
  FREE_OP(opline->op1_type, opline->op1.var);
977
10
  ZVAL_UNDEF(EX_VAR(opline->result.var));
978
10
  HANDLE_EXCEPTION();
979
10
}
980
981
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
982
524
{
983
524
  USE_OPLINE
984
524
  zval *prop, *value;
985
524
  zend_property_info *prop_info;
986
524
  zend_refcounted *garbage = NULL;
987
988
524
  SAVE_OPLINE();
989
990
524
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
991
524
  if (UNEXPECTED(!prop)) {
992
993
29
    UNDEF_RESULT();
994
29
    HANDLE_EXCEPTION();
995
29
  }
996
997
495
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
998
999
495
  if (ZEND_TYPE_IS_SET(prop_info->type)) {
1000
180
    value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1001
1002
315
  } else {
1003
315
    value = zend_assign_to_variable_ex(prop, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
1004
315
  }
1005
1006
495
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1007
42
    ZVAL_COPY(EX_VAR(opline->result.var), value);
1008
42
  }
1009
1010
495
  if (garbage) {
1011
136
    GC_DTOR_NO_REF(garbage);
1012
136
  }
1013
1014
  /* assign_static_prop has two opcodes! */
1015
495
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1016
495
}
1017
1018
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1019
214
{
1020
214
  USE_OPLINE
1021
214
  zval *prop, *value;
1022
214
  zend_property_info *prop_info;
1023
214
  zend_refcounted *garbage = NULL;
1024
1025
214
  SAVE_OPLINE();
1026
1027
214
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
1028
214
  if (UNEXPECTED(!prop)) {
1029
3
    zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1030
3
    UNDEF_RESULT();
1031
3
    HANDLE_EXCEPTION();
1032
3
  }
1033
1034
211
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
1035
1036
211
  if (ZEND_TYPE_IS_SET(prop_info->type)) {
1037
186
    value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1038
186
    zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1039
186
  } else {
1040
25
    value = zend_assign_to_variable_ex(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
1041
25
  }
1042
1043
211
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1044
5
    ZVAL_COPY(EX_VAR(opline->result.var), value);
1045
5
  }
1046
1047
211
  if (garbage) {
1048
169
    GC_DTOR_NO_REF(garbage);
1049
169
  }
1050
1051
  /* assign_static_prop has two opcodes! */
1052
211
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1053
211
}
1054
1055
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1056
440
{
1057
440
  USE_OPLINE
1058
440
  zval *prop, *value;
1059
440
  zend_property_info *prop_info;
1060
440
  zend_refcounted *garbage = NULL;
1061
1062
440
  SAVE_OPLINE();
1063
1064
440
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
1065
440
  if (UNEXPECTED(!prop)) {
1066
17
    zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1067
17
    UNDEF_RESULT();
1068
17
    HANDLE_EXCEPTION();
1069
17
  }
1070
1071
423
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
1072
1073
423
  if (ZEND_TYPE_IS_SET(prop_info->type)) {
1074
140
    value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1075
140
    zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1076
283
  } else {
1077
283
    value = zend_assign_to_variable_ex(prop, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
1078
283
  }
1079
1080
423
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1081
55
    ZVAL_COPY(EX_VAR(opline->result.var), value);
1082
55
  }
1083
1084
423
  if (garbage) {
1085
122
    GC_DTOR_NO_REF(garbage);
1086
122
  }
1087
1088
  /* assign_static_prop has two opcodes! */
1089
423
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1090
423
}
1091
1092
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1093
70
{
1094
70
  USE_OPLINE
1095
70
  zval *prop, *value;
1096
70
  zend_property_info *prop_info;
1097
70
  zend_refcounted *garbage = NULL;
1098
1099
70
  SAVE_OPLINE();
1100
1101
70
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
1102
70
  if (UNEXPECTED(!prop)) {
1103
1104
13
    UNDEF_RESULT();
1105
13
    HANDLE_EXCEPTION();
1106
13
  }
1107
1108
57
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
1109
1110
57
  if (ZEND_TYPE_IS_SET(prop_info->type)) {
1111
17
    value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1112
1113
40
  } else {
1114
40
    value = zend_assign_to_variable_ex(prop, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
1115
40
  }
1116
1117
57
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1118
19
    ZVAL_COPY(EX_VAR(opline->result.var), value);
1119
19
  }
1120
1121
57
  if (garbage) {
1122
0
    GC_DTOR_NO_REF(garbage);
1123
0
  }
1124
1125
  /* assign_static_prop has two opcodes! */
1126
57
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1127
57
}
1128
1129
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1130
258
{
1131
258
  USE_OPLINE
1132
258
  zval *prop, *value_ptr;
1133
258
  zend_property_info *prop_info;
1134
258
  zend_refcounted *garbage = NULL;
1135
1136
258
  SAVE_OPLINE();
1137
1138
258
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
1139
258
  if (UNEXPECTED(!prop)) {
1140
9
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
1141
9
    UNDEF_RESULT();
1142
9
    HANDLE_EXCEPTION();
1143
9
  }
1144
1145
249
  if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
1146
249
   && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) {
1147
10
    zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
1148
10
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
1149
10
    UNDEF_RESULT();
1150
10
    HANDLE_EXCEPTION();
1151
10
  }
1152
1153
239
  value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, BP_VAR_W);
1154
1155
239
  if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
1156
0
    if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC))) {
1157
0
      prop = &EG(uninitialized_zval);
1158
0
    }
1159
239
  } else if (ZEND_TYPE_IS_SET(prop_info->type)) {
1160
215
    prop = zend_assign_to_typed_property_reference(prop_info, prop, value_ptr, &garbage EXECUTE_DATA_CC);
1161
215
  } else {
1162
24
    zend_assign_to_variable_reference(prop, value_ptr, &garbage);
1163
24
  }
1164
1165
239
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1166
18
    ZVAL_COPY(EX_VAR(opline->result.var), prop);
1167
18
  }
1168
1169
239
  if (garbage) {
1170
60
    GC_DTOR(garbage);
1171
60
  }
1172
1173
239
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
1174
239
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1175
239
}
1176
1177
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
1178
417k
{
1179
417k
  zend_execute_data *old_execute_data;
1180
417k
  uint32_t call_info = EX_CALL_INFO();
1181
417k
  SAVE_OPLINE();
1182
1183
417k
  if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) {
1184
24.8k
    EG(current_execute_data) = EX(prev_execute_data);
1185
24.8k
    i_free_compiled_variables(execute_data);
1186
1187
#ifdef ZEND_PREFER_RELOAD
1188
    call_info = EX_CALL_INFO();
1189
#endif
1190
24.8k
    if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
1191
6.76k
      OBJ_RELEASE(Z_OBJ(execute_data->This));
1192
18.1k
    } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1193
1.94k
      OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1194
1.94k
    }
1195
24.8k
    EG(vm_stack_top) = (zval*)execute_data;
1196
24.8k
    execute_data = EX(prev_execute_data);
1197
1198
24.8k
    if (UNEXPECTED(EG(exception) != NULL)) {
1199
3.30k
      zend_rethrow_exception(execute_data);
1200
3.30k
      HANDLE_EXCEPTION_LEAVE();
1201
3.30k
    }
1202
1203
21.5k
    LOAD_NEXT_OPLINE();
1204
21.5k
    ZEND_VM_LEAVE();
1205
392k
  } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
1206
903
    EG(current_execute_data) = EX(prev_execute_data);
1207
903
    i_free_compiled_variables(execute_data);
1208
1209
#ifdef ZEND_PREFER_RELOAD
1210
    call_info = EX_CALL_INFO();
1211
#endif
1212
903
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1213
677
      zend_clean_and_cache_symbol_table(EX(symbol_table));
1214
677
    }
1215
1216
903
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
1217
103
      zend_free_extra_named_params(EX(extra_named_params));
1218
103
    }
1219
1220
    /* Free extra args before releasing the closure,
1221
     * as that may free the op_array. */
1222
903
    zend_vm_stack_free_extra_args_ex(call_info, execute_data);
1223
1224
903
    if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
1225
67
      OBJ_RELEASE(Z_OBJ(execute_data->This));
1226
836
    } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1227
47
      OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1228
47
    }
1229
1230
903
    old_execute_data = execute_data;
1231
903
    execute_data = EX(prev_execute_data);
1232
903
    zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
1233
1234
903
    if (UNEXPECTED(EG(exception) != NULL)) {
1235
114
      zend_rethrow_exception(execute_data);
1236
114
      HANDLE_EXCEPTION_LEAVE();
1237
114
    }
1238
1239
789
    LOAD_NEXT_OPLINE();
1240
789
    ZEND_VM_LEAVE();
1241
391k
  } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
1242
926
    if (EX(func)->op_array.last_var > 0) {
1243
302
      zend_detach_symbol_table(execute_data);
1244
302
      call_info |= ZEND_CALL_NEEDS_REATTACH;
1245
302
    }
1246
926
    zend_destroy_static_vars(&EX(func)->op_array);
1247
926
    destroy_op_array(&EX(func)->op_array);
1248
926
    efree_size(EX(func), sizeof(zend_op_array));
1249
926
    old_execute_data = execute_data;
1250
926
    execute_data = EG(current_execute_data) = EX(prev_execute_data);
1251
926
    zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
1252
1253
926
    if (call_info & ZEND_CALL_NEEDS_REATTACH) {
1254
302
      if (EX(func)->op_array.last_var > 0) {
1255
302
        zend_attach_symbol_table(execute_data);
1256
302
      } else {
1257
0
        ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
1258
0
      }
1259
302
    }
1260
926
    if (UNEXPECTED(EG(exception) != NULL)) {
1261
232
      zend_rethrow_exception(execute_data);
1262
232
      HANDLE_EXCEPTION_LEAVE();
1263
232
    }
1264
1265
694
    LOAD_NEXT_OPLINE();
1266
694
    ZEND_VM_LEAVE();
1267
390k
  } else {
1268
390k
    if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
1269
323k
      EG(current_execute_data) = EX(prev_execute_data);
1270
323k
      i_free_compiled_variables(execute_data);
1271
#ifdef ZEND_PREFER_RELOAD
1272
      call_info = EX_CALL_INFO();
1273
#endif
1274
323k
      if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
1275
8.62k
        if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1276
6.65k
          zend_clean_and_cache_symbol_table(EX(symbol_table));
1277
6.65k
        }
1278
8.62k
        zend_vm_stack_free_extra_args_ex(call_info, execute_data);
1279
8.62k
        if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
1280
113
          zend_free_extra_named_params(EX(extra_named_params));
1281
113
        }
1282
8.62k
      }
1283
323k
      if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1284
11.0k
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1285
11.0k
      }
1286
323k
      ZEND_VM_RETURN();
1287
323k
    } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
1288
67.0k
      zend_array *symbol_table = EX(symbol_table);
1289
1290
67.0k
      if (EX(func)->op_array.last_var > 0) {
1291
43.8k
        zend_detach_symbol_table(execute_data);
1292
43.8k
        call_info |= ZEND_CALL_NEEDS_REATTACH;
1293
43.8k
      }
1294
67.0k
      if (call_info & ZEND_CALL_NEEDS_REATTACH) {
1295
43.8k
        old_execute_data = EX(prev_execute_data);
1296
43.8k
        while (old_execute_data) {
1297
189
          if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1298
189
            if (old_execute_data->symbol_table == symbol_table) {
1299
189
              if (old_execute_data->func->op_array.last_var > 0) {
1300
189
                zend_attach_symbol_table(old_execute_data);
1301
189
              } else {
1302
0
                ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
1303
0
              }
1304
189
            }
1305
189
            break;
1306
189
          }
1307
0
          old_execute_data = old_execute_data->prev_execute_data;
1308
0
        }
1309
43.8k
      }
1310
67.0k
      EG(current_execute_data) = EX(prev_execute_data);
1311
67.0k
      ZEND_VM_RETURN();
1312
67.0k
    }
1313
390k
  }
1314
417k
}
1315
1316
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1317
598k
{
1318
598k
  USE_OPLINE
1319
1320
598k
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
1321
598k
}
1322
1323
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1324
0
{
1325
0
  USE_OPLINE
1326
0
  zend_execute_data *call = EX(call);
1327
0
  zend_function *fbc = call->func;
1328
0
  zval *ret;
1329
0
  zval retval;
1330
1331
0
  SAVE_OPLINE();
1332
0
  EX(call) = call->prev_execute_data;
1333
1334
0
  call->prev_execute_data = execute_data;
1335
0
  EG(current_execute_data) = call;
1336
1337
0
#if ZEND_DEBUG
1338
0
  bool should_throw = zend_internal_call_should_throw(fbc, call);
1339
0
#endif
1340
1341
0
  ret = 0 ? EX_VAR(opline->result.var) : &retval;
1342
0
  ZVAL_NULL(ret);
1343
1344
0
  fbc->internal_function.handler(call, ret);
1345
1346
0
#if ZEND_DEBUG
1347
0
  if (!EG(exception) && call->func) {
1348
0
    if (should_throw) {
1349
0
      zend_internal_call_arginfo_violation(call->func);
1350
0
    }
1351
0
    ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1352
0
      zend_verify_internal_return_type(call->func, ret));
1353
0
    ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1354
0
      ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1355
0
    zend_verify_internal_func_info(call->func, ret);
1356
0
  }
1357
0
#endif
1358
1359
0
  ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1360
1361
0
  EG(current_execute_data) = execute_data;
1362
0
  zend_vm_stack_free_args(call);
1363
1364
0
  uint32_t call_info = ZEND_CALL_INFO(call);
1365
0
  if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1366
0
    if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1367
0
      zend_free_extra_named_params(call->extra_named_params);
1368
0
    }
1369
0
    zend_vm_stack_free_call_frame_ex(call_info, call);
1370
0
  } else {
1371
0
    EG(vm_stack_top) = (zval*)call;
1372
0
  }
1373
1374
0
  if (!0) {
1375
0
    i_zval_ptr_dtor(ret);
1376
0
  }
1377
1378
0
  if (UNEXPECTED(EG(exception) != NULL)) {
1379
0
    zend_rethrow_exception(execute_data);
1380
0
    HANDLE_EXCEPTION();
1381
0
  }
1382
1383
0
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1384
0
  ZEND_VM_CONTINUE();
1385
0
}
1386
1387
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1388
0
{
1389
0
  USE_OPLINE
1390
0
  zend_execute_data *call = EX(call);
1391
0
  zend_function *fbc = call->func;
1392
0
  zval *ret;
1393
0
  zval retval;
1394
1395
0
  SAVE_OPLINE();
1396
0
  EX(call) = call->prev_execute_data;
1397
1398
0
  call->prev_execute_data = execute_data;
1399
0
  EG(current_execute_data) = call;
1400
1401
0
#if ZEND_DEBUG
1402
0
  bool should_throw = zend_internal_call_should_throw(fbc, call);
1403
0
#endif
1404
1405
0
  ret = 1 ? EX_VAR(opline->result.var) : &retval;
1406
0
  ZVAL_NULL(ret);
1407
1408
0
  fbc->internal_function.handler(call, ret);
1409
1410
0
#if ZEND_DEBUG
1411
0
  if (!EG(exception) && call->func) {
1412
0
    if (should_throw) {
1413
0
      zend_internal_call_arginfo_violation(call->func);
1414
0
    }
1415
0
    ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1416
0
      zend_verify_internal_return_type(call->func, ret));
1417
0
    ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1418
0
      ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1419
0
    zend_verify_internal_func_info(call->func, ret);
1420
0
  }
1421
0
#endif
1422
1423
0
  ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1424
1425
0
  EG(current_execute_data) = execute_data;
1426
0
  zend_vm_stack_free_args(call);
1427
1428
0
  uint32_t call_info = ZEND_CALL_INFO(call);
1429
0
  if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1430
0
    if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1431
0
      zend_free_extra_named_params(call->extra_named_params);
1432
0
    }
1433
0
    zend_vm_stack_free_call_frame_ex(call_info, call);
1434
0
  } else {
1435
0
    EG(vm_stack_top) = (zval*)call;
1436
0
  }
1437
1438
0
  if (!1) {
1439
0
    i_zval_ptr_dtor(ret);
1440
0
  }
1441
1442
0
  if (UNEXPECTED(EG(exception) != NULL)) {
1443
0
    zend_rethrow_exception(execute_data);
1444
0
    HANDLE_EXCEPTION();
1445
0
  }
1446
1447
0
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1448
0
  ZEND_VM_CONTINUE();
1449
0
}
1450
1451
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1452
0
{
1453
0
  USE_OPLINE
1454
0
  zend_execute_data *call = EX(call);
1455
0
  zend_function *fbc = call->func;
1456
0
  zval *ret;
1457
0
  zval retval;
1458
1459
0
  SAVE_OPLINE();
1460
0
  EX(call) = call->prev_execute_data;
1461
1462
0
  call->prev_execute_data = execute_data;
1463
0
  EG(current_execute_data) = call;
1464
1465
0
#if ZEND_DEBUG
1466
0
  bool should_throw = zend_internal_call_should_throw(fbc, call);
1467
0
#endif
1468
1469
0
  ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
1470
0
  ZVAL_NULL(ret);
1471
1472
0
  zend_observer_fcall_begin_specialized(call, false);
1473
0
  fbc->internal_function.handler(call, ret);
1474
1475
0
#if ZEND_DEBUG
1476
0
  if (!EG(exception) && call->func) {
1477
0
    if (should_throw) {
1478
0
      zend_internal_call_arginfo_violation(call->func);
1479
0
    }
1480
0
    ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1481
0
      zend_verify_internal_return_type(call->func, ret));
1482
0
    ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1483
0
      ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1484
0
    zend_verify_internal_func_info(call->func, ret);
1485
0
  }
1486
0
#endif
1487
0
  zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
1488
0
  ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1489
1490
0
  EG(current_execute_data) = execute_data;
1491
0
  zend_vm_stack_free_args(call);
1492
1493
0
  uint32_t call_info = ZEND_CALL_INFO(call);
1494
0
  if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1495
0
    if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1496
0
      zend_free_extra_named_params(call->extra_named_params);
1497
0
    }
1498
0
    zend_vm_stack_free_call_frame_ex(call_info, call);
1499
0
  } else {
1500
0
    EG(vm_stack_top) = (zval*)call;
1501
0
  }
1502
1503
0
  if (!RETURN_VALUE_USED(opline)) {
1504
0
    i_zval_ptr_dtor(ret);
1505
0
  }
1506
1507
0
  if (UNEXPECTED(EG(exception) != NULL)) {
1508
0
    zend_rethrow_exception(execute_data);
1509
0
    HANDLE_EXCEPTION();
1510
0
  }
1511
1512
0
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1513
0
  ZEND_VM_CONTINUE();
1514
0
}
1515
1516
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1517
10.2k
{
1518
10.2k
  USE_OPLINE
1519
10.2k
  zend_execute_data *call = EX(call);
1520
10.2k
  zend_function *fbc = call->func;
1521
10.2k
  zval *ret;
1522
1523
10.2k
  SAVE_OPLINE();
1524
10.2k
  EX(call) = call->prev_execute_data;
1525
1526
10.2k
  ret = NULL;
1527
10.2k
  if (0) {
1528
0
    ret = EX_VAR(opline->result.var);
1529
0
  }
1530
1531
10.2k
  call->prev_execute_data = execute_data;
1532
10.2k
  execute_data = call;
1533
10.2k
  i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1534
10.2k
  LOAD_OPLINE_EX();
1535
1536
1537
10.2k
  ZEND_VM_ENTER_EX();
1538
10.2k
}
1539
1540
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1541
6.54k
{
1542
6.54k
  USE_OPLINE
1543
6.54k
  zend_execute_data *call = EX(call);
1544
6.54k
  zend_function *fbc = call->func;
1545
6.54k
  zval *ret;
1546
1547
6.54k
  SAVE_OPLINE();
1548
6.54k
  EX(call) = call->prev_execute_data;
1549
1550
6.54k
  ret = NULL;
1551
6.54k
  if (1) {
1552
6.54k
    ret = EX_VAR(opline->result.var);
1553
6.54k
  }
1554
1555
6.54k
  call->prev_execute_data = execute_data;
1556
6.54k
  execute_data = call;
1557
6.54k
  i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1558
6.54k
  LOAD_OPLINE_EX();
1559
1560
1561
6.54k
  ZEND_VM_ENTER_EX();
1562
6.54k
}
1563
1564
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1565
0
{
1566
0
  USE_OPLINE
1567
0
  zend_execute_data *call = EX(call);
1568
0
  zend_function *fbc = call->func;
1569
0
  zval *ret;
1570
1571
0
  SAVE_OPLINE();
1572
0
  EX(call) = call->prev_execute_data;
1573
1574
0
  ret = NULL;
1575
0
  if (RETURN_VALUE_USED(opline)) {
1576
0
    ret = EX_VAR(opline->result.var);
1577
0
  }
1578
1579
0
  call->prev_execute_data = execute_data;
1580
0
  execute_data = call;
1581
0
  i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1582
0
  LOAD_OPLINE_EX();
1583
0
  SAVE_OPLINE();
1584
0
  zend_observer_fcall_begin_specialized(execute_data, false);
1585
1586
0
  ZEND_VM_ENTER_EX();
1587
0
}
1588
1589
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1590
144
{
1591
144
  USE_OPLINE
1592
144
  zend_execute_data *call = EX(call);
1593
144
  zend_function *fbc = call->func;
1594
144
  zval *ret;
1595
144
  zval retval;
1596
1597
144
  SAVE_OPLINE();
1598
144
  EX(call) = call->prev_execute_data;
1599
1600
144
  const uint32_t no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
1601
1602
144
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
1603
144
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
1604
82
      zend_deprecated_function(fbc);
1605
82
    }
1606
144
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
1607
65
      zend_nodiscard_function(fbc);
1608
65
    }
1609
144
    if (UNEXPECTED(EG(exception) != NULL)) {
1610
27
      UNDEF_RESULT();
1611
27
      if (!0) {
1612
27
        ret = &retval;
1613
27
        ZVAL_UNDEF(ret);
1614
27
      }
1615
27
      goto fcall_by_name_end;
1616
27
    }
1617
144
  }
1618
1619
117
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1620
117
    ret = NULL;
1621
117
    if (0) {
1622
0
      ret = EX_VAR(opline->result.var);
1623
0
    }
1624
1625
117
    call->prev_execute_data = execute_data;
1626
117
    execute_data = call;
1627
117
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1628
117
    LOAD_OPLINE_EX();
1629
1630
1631
117
    ZEND_VM_ENTER_EX();
1632
117
  } else {
1633
0
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1634
0
    if (0) {
1635
0
      ret = NULL;
1636
0
    }
1637
1638
0
    call->prev_execute_data = execute_data;
1639
0
    EG(current_execute_data) = call;
1640
1641
0
#if ZEND_DEBUG
1642
0
    bool should_throw = zend_internal_call_should_throw(fbc, call);
1643
0
#endif
1644
1645
0
    ret = 0 ? EX_VAR(opline->result.var) : &retval;
1646
0
    ZVAL_NULL(ret);
1647
1648
0
    fbc->internal_function.handler(call, ret);
1649
1650
0
#if ZEND_DEBUG
1651
0
    if (!EG(exception) && call->func) {
1652
0
      if (should_throw) {
1653
0
        zend_internal_call_arginfo_violation(call->func);
1654
0
      }
1655
0
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1656
0
        zend_verify_internal_return_type(call->func, ret));
1657
0
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1658
0
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1659
0
      zend_verify_internal_func_info(call->func, ret);
1660
0
    }
1661
0
#endif
1662
1663
0
    ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1664
1665
0
    EG(current_execute_data) = execute_data;
1666
1667
0
    goto fcall_by_name_end;
1668
0
  }
1669
1670
0
  if (0) {
1671
27
fcall_by_name_end:
1672
1673
27
    zend_vm_stack_free_args(call);
1674
1675
27
    uint32_t call_info = ZEND_CALL_INFO(call);
1676
27
    if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1677
0
      if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1678
0
        zend_free_extra_named_params(call->extra_named_params);
1679
0
      }
1680
0
      zend_vm_stack_free_call_frame_ex(call_info, call);
1681
27
    } else {
1682
27
      EG(vm_stack_top) = (zval*)call;
1683
27
    }
1684
1685
27
    if (!0) {
1686
27
      i_zval_ptr_dtor(ret);
1687
27
    }
1688
27
  }
1689
1690
27
  if (UNEXPECTED(EG(exception) != NULL)) {
1691
27
    zend_rethrow_exception(execute_data);
1692
27
    HANDLE_EXCEPTION();
1693
27
  }
1694
27
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1695
0
  ZEND_VM_CONTINUE();
1696
27
}
1697
1698
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1699
6
{
1700
6
  USE_OPLINE
1701
6
  zend_execute_data *call = EX(call);
1702
6
  zend_function *fbc = call->func;
1703
6
  zval *ret;
1704
6
  zval retval;
1705
1706
6
  SAVE_OPLINE();
1707
6
  EX(call) = call->prev_execute_data;
1708
1709
6
  const uint32_t no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
1710
1711
6
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
1712
6
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
1713
6
      zend_deprecated_function(fbc);
1714
6
    }
1715
6
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
1716
0
      zend_nodiscard_function(fbc);
1717
0
    }
1718
6
    if (UNEXPECTED(EG(exception) != NULL)) {
1719
4
      UNDEF_RESULT();
1720
4
      if (!1) {
1721
0
        ret = &retval;
1722
0
        ZVAL_UNDEF(ret);
1723
0
      }
1724
4
      goto fcall_by_name_end;
1725
4
    }
1726
6
  }
1727
1728
2
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1729
2
    ret = NULL;
1730
2
    if (1) {
1731
2
      ret = EX_VAR(opline->result.var);
1732
2
    }
1733
1734
2
    call->prev_execute_data = execute_data;
1735
2
    execute_data = call;
1736
2
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1737
2
    LOAD_OPLINE_EX();
1738
1739
1740
2
    ZEND_VM_ENTER_EX();
1741
2
  } else {
1742
0
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1743
0
    if (0) {
1744
0
      ret = NULL;
1745
0
    }
1746
1747
0
    call->prev_execute_data = execute_data;
1748
0
    EG(current_execute_data) = call;
1749
1750
0
#if ZEND_DEBUG
1751
0
    bool should_throw = zend_internal_call_should_throw(fbc, call);
1752
0
#endif
1753
1754
0
    ret = 1 ? EX_VAR(opline->result.var) : &retval;
1755
0
    ZVAL_NULL(ret);
1756
1757
0
    fbc->internal_function.handler(call, ret);
1758
1759
0
#if ZEND_DEBUG
1760
0
    if (!EG(exception) && call->func) {
1761
0
      if (should_throw) {
1762
0
        zend_internal_call_arginfo_violation(call->func);
1763
0
      }
1764
0
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1765
0
        zend_verify_internal_return_type(call->func, ret));
1766
0
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1767
0
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1768
0
      zend_verify_internal_func_info(call->func, ret);
1769
0
    }
1770
0
#endif
1771
1772
0
    ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1773
1774
0
    EG(current_execute_data) = execute_data;
1775
1776
0
    goto fcall_by_name_end;
1777
0
  }
1778
1779
0
  if (0) {
1780
4
fcall_by_name_end:
1781
1782
4
    zend_vm_stack_free_args(call);
1783
1784
4
    uint32_t call_info = ZEND_CALL_INFO(call);
1785
4
    if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1786
0
      if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1787
0
        zend_free_extra_named_params(call->extra_named_params);
1788
0
      }
1789
0
      zend_vm_stack_free_call_frame_ex(call_info, call);
1790
4
    } else {
1791
4
      EG(vm_stack_top) = (zval*)call;
1792
4
    }
1793
1794
4
    if (!1) {
1795
0
      i_zval_ptr_dtor(ret);
1796
0
    }
1797
4
  }
1798
1799
4
  if (UNEXPECTED(EG(exception) != NULL)) {
1800
4
    zend_rethrow_exception(execute_data);
1801
4
    HANDLE_EXCEPTION();
1802
4
  }
1803
4
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1804
0
  ZEND_VM_CONTINUE();
1805
4
}
1806
1807
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1808
0
{
1809
0
  USE_OPLINE
1810
0
  zend_execute_data *call = EX(call);
1811
0
  zend_function *fbc = call->func;
1812
0
  zval *ret;
1813
0
  zval retval;
1814
1815
0
  SAVE_OPLINE();
1816
0
  EX(call) = call->prev_execute_data;
1817
1818
0
  const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
1819
1820
0
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
1821
0
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
1822
0
      zend_deprecated_function(fbc);
1823
0
    }
1824
0
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
1825
0
      zend_nodiscard_function(fbc);
1826
0
    }
1827
0
    if (UNEXPECTED(EG(exception) != NULL)) {
1828
0
      UNDEF_RESULT();
1829
0
      if (!RETURN_VALUE_USED(opline)) {
1830
0
        ret = &retval;
1831
0
        ZVAL_UNDEF(ret);
1832
0
      }
1833
0
      goto fcall_by_name_end;
1834
0
    }
1835
0
  }
1836
1837
0
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1838
0
    ret = NULL;
1839
0
    if (RETURN_VALUE_USED(opline)) {
1840
0
      ret = EX_VAR(opline->result.var);
1841
0
    }
1842
1843
0
    call->prev_execute_data = execute_data;
1844
0
    execute_data = call;
1845
0
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1846
0
    LOAD_OPLINE_EX();
1847
0
    SAVE_OPLINE();
1848
0
    zend_observer_fcall_begin_specialized(execute_data, false);
1849
1850
0
    ZEND_VM_ENTER_EX();
1851
0
  } else {
1852
0
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1853
0
    if (1) {
1854
0
      ret = NULL;
1855
0
    }
1856
1857
0
    call->prev_execute_data = execute_data;
1858
0
    EG(current_execute_data) = call;
1859
1860
0
#if ZEND_DEBUG
1861
0
    bool should_throw = zend_internal_call_should_throw(fbc, call);
1862
0
#endif
1863
1864
0
    ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
1865
0
    ZVAL_NULL(ret);
1866
1867
0
    zend_observer_fcall_begin_specialized(call, false);
1868
0
    fbc->internal_function.handler(call, ret);
1869
1870
0
#if ZEND_DEBUG
1871
0
    if (!EG(exception) && call->func) {
1872
0
      if (should_throw) {
1873
0
        zend_internal_call_arginfo_violation(call->func);
1874
0
      }
1875
0
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1876
0
        zend_verify_internal_return_type(call->func, ret));
1877
0
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1878
0
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1879
0
      zend_verify_internal_func_info(call->func, ret);
1880
0
    }
1881
0
#endif
1882
0
    zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
1883
0
    ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1884
1885
0
    EG(current_execute_data) = execute_data;
1886
1887
0
    goto fcall_by_name_end;
1888
0
  }
1889
1890
0
  if (0) {
1891
0
fcall_by_name_end:
1892
1893
0
    zend_vm_stack_free_args(call);
1894
1895
0
    uint32_t call_info = ZEND_CALL_INFO(call);
1896
0
    if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1897
0
      if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1898
0
        zend_free_extra_named_params(call->extra_named_params);
1899
0
      }
1900
0
      zend_vm_stack_free_call_frame_ex(call_info, call);
1901
0
    } else {
1902
0
      EG(vm_stack_top) = (zval*)call;
1903
0
    }
1904
1905
0
    if (!RETURN_VALUE_USED(opline)) {
1906
0
      i_zval_ptr_dtor(ret);
1907
0
    }
1908
0
  }
1909
1910
0
  if (UNEXPECTED(EG(exception) != NULL)) {
1911
0
    zend_rethrow_exception(execute_data);
1912
0
    HANDLE_EXCEPTION();
1913
0
  }
1914
0
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1915
0
  ZEND_VM_CONTINUE();
1916
0
}
1917
1918
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1919
1.03M
{
1920
1.03M
  USE_OPLINE
1921
1.03M
  zend_execute_data *call = EX(call);
1922
1.03M
  zend_function *fbc = call->func;
1923
1.03M
  zval *ret;
1924
1.03M
  zval retval;
1925
1926
1.03M
  SAVE_OPLINE();
1927
1.03M
  EX(call) = call->prev_execute_data;
1928
1929
1.03M
  const uint32_t no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
1930
1931
1.03M
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
1932
277
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
1933
186
      zend_deprecated_function(fbc);
1934
186
    }
1935
277
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
1936
93
      zend_nodiscard_function(fbc);
1937
93
    }
1938
277
    if (UNEXPECTED(EG(exception) != NULL)) {
1939
49
      if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
1940
7
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
1941
7
      }
1942
49
      UNDEF_RESULT();
1943
49
      if (!0) {
1944
49
        ret = &retval;
1945
49
        ZVAL_UNDEF(ret);
1946
49
      }
1947
49
      goto fcall_end;
1948
49
    }
1949
277
  }
1950
1951
1.03M
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1952
33.3k
    ret = NULL;
1953
33.3k
    if (0) {
1954
0
      ret = EX_VAR(opline->result.var);
1955
0
    }
1956
1957
33.3k
    call->prev_execute_data = execute_data;
1958
33.3k
    execute_data = call;
1959
33.3k
    i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
1960
1961
33.3k
    if (EXPECTED(zend_execute_ex == execute_ex)) {
1962
7.65k
      LOAD_OPLINE_EX();
1963
1964
1965
7.65k
      ZEND_VM_ENTER_EX();
1966
25.7k
    } else {
1967
25.7k
      SAVE_OPLINE_EX();
1968
1969
25.7k
      execute_data = EX(prev_execute_data);
1970
25.7k
      LOAD_OPLINE();
1971
25.7k
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
1972
25.7k
      zend_execute_ex(call);
1973
25.7k
    }
1974
1.00M
  } else {
1975
1.00M
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1976
1.00M
    if (0) {
1977
0
      ret = NULL;
1978
0
    }
1979
1980
1.00M
    call->prev_execute_data = execute_data;
1981
1.00M
    EG(current_execute_data) = call;
1982
1983
1.00M
#if ZEND_DEBUG
1984
1.00M
    bool should_throw = zend_internal_call_should_throw(fbc, call);
1985
1.00M
#endif
1986
1987
1.00M
    ret = 0 ? EX_VAR(opline->result.var) : &retval;
1988
1.00M
    ZVAL_NULL(ret);
1989
1990
1.00M
    if (!zend_execute_internal) {
1991
      /* saves one function call if zend_execute_internal is not used */
1992
0
      fbc->internal_function.handler(call, ret);
1993
1.00M
    } else {
1994
1.00M
      zend_execute_internal(call, ret);
1995
1.00M
    }
1996
1997
1.00M
#if ZEND_DEBUG
1998
1.00M
    if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
1999
384k
      if (should_throw) {
2000
0
        zend_internal_call_arginfo_violation(call->func);
2001
0
      }
2002
384k
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
2003
384k
        zend_verify_internal_return_type(call->func, ret));
2004
384k
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2005
384k
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2006
384k
      zend_verify_internal_func_info(call->func, ret);
2007
384k
    }
2008
1.00M
#endif
2009
2010
1.00M
    ZEND_VM_FCALL_INTERRUPT_CHECK(call);
2011
2012
1.00M
    EG(current_execute_data) = execute_data;
2013
2014
1.00M
    goto fcall_end;
2015
1.00M
  }
2016
2017
25.7k
  if (0) {
2018
989k
fcall_end:
2019
2020
989k
    zend_vm_stack_free_args(call);
2021
989k
    if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2022
170
      zend_free_extra_named_params(call->extra_named_params);
2023
170
    }
2024
2025
989k
    if (!0) {
2026
989k
      i_zval_ptr_dtor(ret);
2027
989k
    }
2028
989k
  }
2029
2030
1.01M
  if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2031
709k
    OBJ_RELEASE(Z_OBJ(call->This));
2032
709k
  }
2033
2034
1.01M
  zend_vm_stack_free_call_frame(call);
2035
1.01M
  if (UNEXPECTED(EG(exception) != NULL)) {
2036
607k
    zend_rethrow_exception(execute_data);
2037
607k
    HANDLE_EXCEPTION();
2038
607k
  }
2039
1.01M
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
2040
408k
  ZEND_VM_CONTINUE();
2041
1.01M
}
2042
2043
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2044
257k
{
2045
257k
  USE_OPLINE
2046
257k
  zend_execute_data *call = EX(call);
2047
257k
  zend_function *fbc = call->func;
2048
257k
  zval *ret;
2049
257k
  zval retval;
2050
2051
257k
  SAVE_OPLINE();
2052
257k
  EX(call) = call->prev_execute_data;
2053
2054
257k
  const uint32_t no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
2055
2056
257k
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
2057
38
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
2058
38
      zend_deprecated_function(fbc);
2059
38
    }
2060
38
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
2061
0
      zend_nodiscard_function(fbc);
2062
0
    }
2063
38
    if (UNEXPECTED(EG(exception) != NULL)) {
2064
3
      if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
2065
0
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
2066
0
      }
2067
3
      UNDEF_RESULT();
2068
3
      if (!1) {
2069
0
        ret = &retval;
2070
0
        ZVAL_UNDEF(ret);
2071
0
      }
2072
3
      goto fcall_end;
2073
3
    }
2074
38
  }
2075
2076
257k
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
2077
16.4k
    ret = NULL;
2078
16.4k
    if (1) {
2079
16.4k
      ret = EX_VAR(opline->result.var);
2080
16.4k
    }
2081
2082
16.4k
    call->prev_execute_data = execute_data;
2083
16.4k
    execute_data = call;
2084
16.4k
    i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
2085
2086
16.4k
    if (EXPECTED(zend_execute_ex == execute_ex)) {
2087
3.11k
      LOAD_OPLINE_EX();
2088
2089
2090
3.11k
      ZEND_VM_ENTER_EX();
2091
13.3k
    } else {
2092
13.3k
      SAVE_OPLINE_EX();
2093
2094
13.3k
      execute_data = EX(prev_execute_data);
2095
13.3k
      LOAD_OPLINE();
2096
13.3k
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
2097
13.3k
      zend_execute_ex(call);
2098
13.3k
    }
2099
241k
  } else {
2100
241k
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
2101
241k
    if (0) {
2102
0
      ret = NULL;
2103
0
    }
2104
2105
241k
    call->prev_execute_data = execute_data;
2106
241k
    EG(current_execute_data) = call;
2107
2108
241k
#if ZEND_DEBUG
2109
241k
    bool should_throw = zend_internal_call_should_throw(fbc, call);
2110
241k
#endif
2111
2112
241k
    ret = 1 ? EX_VAR(opline->result.var) : &retval;
2113
241k
    ZVAL_NULL(ret);
2114
2115
241k
    if (!zend_execute_internal) {
2116
      /* saves one function call if zend_execute_internal is not used */
2117
0
      fbc->internal_function.handler(call, ret);
2118
241k
    } else {
2119
241k
      zend_execute_internal(call, ret);
2120
241k
    }
2121
2122
241k
#if ZEND_DEBUG
2123
241k
    if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
2124
238k
      if (should_throw) {
2125
0
        zend_internal_call_arginfo_violation(call->func);
2126
0
      }
2127
238k
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
2128
238k
        zend_verify_internal_return_type(call->func, ret));
2129
238k
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2130
238k
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2131
238k
      zend_verify_internal_func_info(call->func, ret);
2132
238k
    }
2133
241k
#endif
2134
2135
241k
    ZEND_VM_FCALL_INTERRUPT_CHECK(call);
2136
2137
241k
    EG(current_execute_data) = execute_data;
2138
2139
241k
    goto fcall_end;
2140
241k
  }
2141
2142
13.3k
  if (0) {
2143
240k
fcall_end:
2144
2145
240k
    zend_vm_stack_free_args(call);
2146
240k
    if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2147
26
      zend_free_extra_named_params(call->extra_named_params);
2148
26
    }
2149
2150
240k
    if (!1) {
2151
0
      i_zval_ptr_dtor(ret);
2152
0
    }
2153
240k
  }
2154
2155
253k
  if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2156
105k
    OBJ_RELEASE(Z_OBJ(call->This));
2157
105k
  }
2158
2159
253k
  zend_vm_stack_free_call_frame(call);
2160
253k
  if (UNEXPECTED(EG(exception) != NULL)) {
2161
2.09k
    zend_rethrow_exception(execute_data);
2162
2.09k
    HANDLE_EXCEPTION();
2163
2.09k
  }
2164
253k
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
2165
251k
  ZEND_VM_CONTINUE();
2166
253k
}
2167
2168
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2169
0
{
2170
0
  USE_OPLINE
2171
0
  zend_execute_data *call = EX(call);
2172
0
  zend_function *fbc = call->func;
2173
0
  zval *ret;
2174
0
  zval retval;
2175
2176
0
  SAVE_OPLINE();
2177
0
  EX(call) = call->prev_execute_data;
2178
2179
0
  const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD;
2180
2181
0
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
2182
0
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
2183
0
      zend_deprecated_function(fbc);
2184
0
    }
2185
0
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
2186
0
      zend_nodiscard_function(fbc);
2187
0
    }
2188
0
    if (UNEXPECTED(EG(exception) != NULL)) {
2189
0
      if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
2190
0
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
2191
0
      }
2192
0
      UNDEF_RESULT();
2193
0
      if (!RETURN_VALUE_USED(opline)) {
2194
0
        ret = &retval;
2195
0
        ZVAL_UNDEF(ret);
2196
0
      }
2197
0
      goto fcall_end;
2198
0
    }
2199
0
  }
2200
2201
0
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
2202
0
    ret = NULL;
2203
0
    if (RETURN_VALUE_USED(opline)) {
2204
0
      ret = EX_VAR(opline->result.var);
2205
0
    }
2206
2207
0
    call->prev_execute_data = execute_data;
2208
0
    execute_data = call;
2209
0
    i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
2210
2211
0
    if (EXPECTED(zend_execute_ex == execute_ex)) {
2212
0
      LOAD_OPLINE_EX();
2213
0
      SAVE_OPLINE();
2214
0
      zend_observer_fcall_begin_specialized(execute_data, false);
2215
0
      ZEND_VM_ENTER_EX();
2216
0
    } else {
2217
0
      SAVE_OPLINE_EX();
2218
0
      zend_observer_fcall_begin_specialized(execute_data, false);
2219
0
      execute_data = EX(prev_execute_data);
2220
0
      LOAD_OPLINE();
2221
0
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
2222
0
      zend_execute_ex(call);
2223
0
    }
2224
0
  } else {
2225
0
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
2226
0
    if (1) {
2227
0
      ret = NULL;
2228
0
    }
2229
2230
0
    call->prev_execute_data = execute_data;
2231
0
    EG(current_execute_data) = call;
2232
2233
0
#if ZEND_DEBUG
2234
0
    bool should_throw = zend_internal_call_should_throw(fbc, call);
2235
0
#endif
2236
2237
0
    ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
2238
0
    ZVAL_NULL(ret);
2239
2240
0
    zend_observer_fcall_begin_specialized(call, false);
2241
0
    if (!zend_execute_internal) {
2242
      /* saves one function call if zend_execute_internal is not used */
2243
0
      fbc->internal_function.handler(call, ret);
2244
0
    } else {
2245
0
      zend_execute_internal(call, ret);
2246
0
    }
2247
2248
0
#if ZEND_DEBUG
2249
0
    if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
2250
0
      if (should_throw) {
2251
0
        zend_internal_call_arginfo_violation(call->func);
2252
0
      }
2253
0
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
2254
0
        zend_verify_internal_return_type(call->func, ret));
2255
0
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2256
0
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2257
0
      zend_verify_internal_func_info(call->func, ret);
2258
0
    }
2259
0
#endif
2260
0
    zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
2261
0
    ZEND_VM_FCALL_INTERRUPT_CHECK(call);
2262
2263
0
    EG(current_execute_data) = execute_data;
2264
2265
0
    goto fcall_end;
2266
0
  }
2267
2268
0
  if (0) {
2269
0
fcall_end:
2270
2271
0
    zend_vm_stack_free_args(call);
2272
0
    if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2273
0
      zend_free_extra_named_params(call->extra_named_params);
2274
0
    }
2275
2276
0
    if (!RETURN_VALUE_USED(opline)) {
2277
0
      i_zval_ptr_dtor(ret);
2278
0
    }
2279
0
  }
2280
2281
0
  if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2282
0
    OBJ_RELEASE(Z_OBJ(call->This));
2283
0
  }
2284
2285
0
  zend_vm_stack_free_call_frame(call);
2286
0
  if (UNEXPECTED(EG(exception) != NULL)) {
2287
0
    zend_rethrow_exception(execute_data);
2288
0
    HANDLE_EXCEPTION();
2289
0
  }
2290
0
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
2291
0
  ZEND_VM_CONTINUE();
2292
0
}
2293
2294
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2295
4.97k
{
2296
4.97k
  zval *return_value = EX(return_value);
2297
2298
4.97k
  if (EXPECTED(return_value)) {
2299
4.94k
    USE_OPLINE
2300
4.94k
    zend_generator *generator;
2301
4.94k
    zend_execute_data *gen_execute_data;
2302
4.94k
    uint32_t num_args, used_stack, call_info;
2303
2304
4.94k
    SAVE_OPLINE();
2305
4.94k
    object_init_ex(return_value, zend_ce_generator);
2306
2307
    /*
2308
     * Normally the execute_data is allocated on the VM stack (because it does
2309
     * not actually do any allocation and thus is faster). For generators
2310
     * though this behavior would be suboptimal, because the (rather large)
2311
     * structure would have to be copied back and forth every time execution is
2312
     * suspended or resumed. That's why for generators the execution context
2313
     * is allocated on heap.
2314
     */
2315
4.94k
    num_args = EX_NUM_ARGS();
2316
4.94k
    if (EXPECTED(num_args <= EX(func)->op_array.num_args)) {
2317
4.69k
      used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var + EX(func)->op_array.T) * sizeof(zval);
2318
4.69k
      gen_execute_data = (zend_execute_data*)emalloc(used_stack);
2319
4.69k
      used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var) * sizeof(zval);
2320
4.69k
    } else {
2321
253
      used_stack = (ZEND_CALL_FRAME_SLOT + num_args + EX(func)->op_array.last_var + EX(func)->op_array.T - EX(func)->op_array.num_args) * sizeof(zval);
2322
253
      gen_execute_data = (zend_execute_data*)emalloc(used_stack);
2323
253
    }
2324
4.94k
    memcpy(gen_execute_data, execute_data, used_stack);
2325
2326
    /* Save execution context in generator object. */
2327
4.94k
    generator = (zend_generator *) Z_OBJ_P(EX(return_value));
2328
4.94k
    generator->func = gen_execute_data->func;
2329
4.94k
    generator->execute_data = gen_execute_data;
2330
4.94k
    generator->frozen_call_stack = NULL;
2331
4.94k
    generator->execute_fake.opline = NULL;
2332
4.94k
    generator->execute_fake.func = NULL;
2333
4.94k
    generator->execute_fake.prev_execute_data = NULL;
2334
4.94k
    ZVAL_OBJ(&generator->execute_fake.This, (zend_object *) generator);
2335
2336
4.94k
    gen_execute_data->opline = opline;
2337
    /* EX(return_value) keeps pointer to zend_object (not a real zval) */
2338
4.94k
    gen_execute_data->return_value = (zval*)generator;
2339
4.94k
    call_info = Z_TYPE_INFO(EX(This));
2340
4.94k
    if ((call_info & Z_TYPE_MASK) == IS_OBJECT
2341
4.94k
     && (!(call_info & (ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS))
2342
       /* Bug #72523 */
2343
188
      || UNEXPECTED(zend_execute_ex != execute_ex))) {
2344
136
      ZEND_ADD_CALL_FLAG_EX(call_info, ZEND_CALL_RELEASE_THIS);
2345
136
      Z_ADDREF(gen_execute_data->This);
2346
136
    }
2347
4.94k
    ZEND_ADD_CALL_FLAG_EX(call_info, (ZEND_CALL_TOP_FUNCTION | ZEND_CALL_ALLOCATED | ZEND_CALL_GENERATOR));
2348
4.94k
    Z_TYPE_INFO(gen_execute_data->This) = call_info;
2349
4.94k
    gen_execute_data->prev_execute_data = NULL;
2350
2351
4.94k
    call_info = EX_CALL_INFO();
2352
4.94k
    EG(current_execute_data) = EX(prev_execute_data);
2353
4.94k
    if (EXPECTED(!(call_info & (ZEND_CALL_TOP|ZEND_CALL_ALLOCATED)))) {
2354
1.96k
      EG(vm_stack_top) = (zval*)execute_data;
2355
1.96k
      execute_data = EX(prev_execute_data);
2356
1.96k
      LOAD_NEXT_OPLINE();
2357
1.96k
      ZEND_VM_LEAVE();
2358
2.98k
    } else if (EXPECTED(!(call_info & ZEND_CALL_TOP))) {
2359
10
      zend_execute_data *old_execute_data = execute_data;
2360
10
      execute_data = EX(prev_execute_data);
2361
10
      zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
2362
10
      LOAD_NEXT_OPLINE();
2363
10
      ZEND_VM_LEAVE();
2364
2.97k
    } else {
2365
2.97k
      ZEND_VM_RETURN();
2366
2.97k
    }
2367
4.94k
  } else {
2368
32
    ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
2369
32
  }
2370
4.97k
}
2371
2372
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX uint32_t _arg_num, zval *_arg)
2373
118
{
2374
118
  USE_OPLINE
2375
2376
118
  SAVE_OPLINE();
2377
2378
118
  zend_cannot_pass_by_reference(_arg_num);
2379
118
  FREE_OP(opline->op1_type, opline->op1.var);
2380
118
  ZVAL_UNDEF(_arg);
2381
118
  HANDLE_EXCEPTION();
2382
118
}
2383
2384
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2385
1.71k
{
2386
1.71k
  USE_OPLINE
2387
1.71k
  zval *args;
2388
1.71k
  uint32_t arg_num;
2389
2390
1.71k
  SAVE_OPLINE();
2391
1.71k
  args = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
2392
1.71k
  arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1;
2393
2394
1.71k
send_again:
2395
1.71k
  if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
2396
1.48k
    HashTable *ht = Z_ARRVAL_P(args);
2397
1.48k
    zval *arg, *top;
2398
1.48k
    zend_string *name;
2399
1.48k
    bool have_named_params = 0;
2400
2401
1.48k
    zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht));
2402
2403
    // TODO: Speed this up using a flag that specifies whether there are any ref parameters.
2404
1.48k
    if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) {
2405
1.05k
      uint32_t tmp_arg_num = arg_num;
2406
1.05k
      bool separate = 0;
2407
2408
      /* check if any of arguments are going to be passed by reference */
2409
4.52k
      ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2410
4.52k
        if (UNEXPECTED(name)) {
2411
1.17k
          void *cache_slot[2] = {NULL, NULL};
2412
1.17k
          tmp_arg_num = zend_get_arg_offset_by_name(
2413
1.17k
            EX(call)->func, name, cache_slot) + 1;
2414
1.17k
        }
2415
4.52k
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, tmp_arg_num)) {
2416
123
          separate = 1;
2417
123
          break;
2418
123
        }
2419
1.61k
        tmp_arg_num++;
2420
1.61k
      } ZEND_HASH_FOREACH_END();
2421
1.05k
      if (separate) {
2422
123
        SEPARATE_ARRAY(args);
2423
123
        ht = Z_ARRVAL_P(args);
2424
123
      }
2425
1.05k
    }
2426
2427
1.16M
    ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2428
1.16M
      if (UNEXPECTED(name)) {
2429
1.33k
        void *cache_slot[2] = {NULL, NULL};
2430
1.33k
        have_named_params = 1;
2431
1.33k
        top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2432
1.33k
        if (UNEXPECTED(!top)) {
2433
17
          FREE_OP(opline->op1_type, opline->op1.var);
2434
17
          HANDLE_EXCEPTION();
2435
17
        }
2436
580k
      } else {
2437
580k
        if (have_named_params) {
2438
12
          zend_throw_error(NULL,
2439
12
            "Cannot use positional argument after named argument during unpacking");
2440
12
          FREE_OP(opline->op1_type, opline->op1.var);
2441
12
          HANDLE_EXCEPTION();
2442
12
        }
2443
2444
580k
        top = ZEND_CALL_ARG(EX(call), arg_num);
2445
580k
        ZEND_CALL_NUM_ARGS(EX(call))++;
2446
580k
      }
2447
2448
581k
      if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2449
346
        if (Z_ISREF_P(arg)) {
2450
17
          Z_ADDREF_P(arg);
2451
17
          ZVAL_REF(top, Z_REF_P(arg));
2452
329
        } else if (opline->op1_type & (IS_VAR|IS_CV)) {
2453
          /* array is already separated above */
2454
269
          ZVAL_MAKE_REF_EX(arg, 2);
2455
269
          ZVAL_REF(top, Z_REF_P(arg));
2456
269
        } else {
2457
60
          Z_TRY_ADDREF_P(arg);
2458
60
          ZVAL_NEW_REF(top, arg);
2459
60
        }
2460
581k
      } else {
2461
581k
        ZVAL_COPY_DEREF(top, arg);
2462
581k
      }
2463
2464
581k
      arg_num++;
2465
581k
    } ZEND_HASH_FOREACH_END();
2466
2467
1.48k
  } else if (EXPECTED(Z_TYPE_P(args) == IS_OBJECT)) {
2468
193
    zend_class_entry *ce = Z_OBJCE_P(args);
2469
193
    zend_object_iterator *iter;
2470
193
    bool have_named_params = 0;
2471
2472
193
    if (!ce || !ce->get_iterator) {
2473
16
      zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(args));
2474
177
    } else {
2475
2476
177
      iter = ce->get_iterator(ce, args, 0);
2477
177
      if (UNEXPECTED(!iter)) {
2478
5
        FREE_OP(opline->op1_type, opline->op1.var);
2479
5
        if (!EG(exception)) {
2480
0
          zend_throw_exception_ex(
2481
0
            NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
2482
0
          );
2483
0
        }
2484
5
        HANDLE_EXCEPTION();
2485
5
      }
2486
2487
172
      const zend_object_iterator_funcs *funcs = iter->funcs;
2488
172
      if (funcs->rewind) {
2489
172
        funcs->rewind(iter);
2490
172
      }
2491
2492
516
      for (; funcs->valid(iter) == SUCCESS; ++arg_num) {
2493
378
        zval *arg, *top;
2494
2495
378
        if (UNEXPECTED(EG(exception) != NULL)) {
2496
0
          break;
2497
0
        }
2498
2499
378
        arg = funcs->get_current_data(iter);
2500
378
        if (UNEXPECTED(EG(exception) != NULL)) {
2501
0
          break;
2502
0
        }
2503
2504
378
        zend_string *name = NULL;
2505
378
        if (funcs->get_current_key) {
2506
378
          zval key;
2507
378
          funcs->get_current_key(iter, &key);
2508
378
          if (UNEXPECTED(EG(exception) != NULL)) {
2509
0
            break;
2510
0
          }
2511
2512
378
          if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) {
2513
121
            if (UNEXPECTED(Z_TYPE(key) != IS_STRING)) {
2514
11
              zend_throw_error(NULL,
2515
11
                "Keys must be of type int|string during argument unpacking");
2516
11
              zval_ptr_dtor(&key);
2517
11
              break;
2518
11
            }
2519
2520
110
            name = Z_STR_P(&key);
2521
110
          }
2522
378
        }
2523
2524
367
        if (UNEXPECTED(name)) {
2525
110
          void *cache_slot[2] = {NULL, NULL};
2526
110
          have_named_params = 1;
2527
110
          top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2528
110
          if (UNEXPECTED(!top)) {
2529
10
            zend_string_release(name);
2530
10
            break;
2531
10
          }
2532
2533
100
          ZVAL_DEREF(arg);
2534
100
          Z_TRY_ADDREF_P(arg);
2535
2536
100
          if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2537
5
            zend_error(
2538
5
              E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
2539
5
              " by unpacking a Traversable, passing by-value instead", arg_num,
2540
5
              EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
2541
5
              EX(call)->func->common.scope ? "::" : "",
2542
5
              ZSTR_VAL(EX(call)->func->common.function_name)
2543
5
            );
2544
5
            ZVAL_NEW_REF(top, arg);
2545
95
          } else {
2546
95
            ZVAL_COPY_VALUE(top, arg);
2547
95
          }
2548
2549
100
          zend_string_release(name);
2550
257
        } else {
2551
257
          if (have_named_params) {
2552
13
            zend_throw_error(NULL,
2553
13
              "Cannot use positional argument after named argument during unpacking");
2554
13
            break;
2555
13
          }
2556
2557
244
          zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1);
2558
244
          top = ZEND_CALL_ARG(EX(call), arg_num);
2559
244
          ZVAL_DEREF(arg);
2560
244
          Z_TRY_ADDREF_P(arg);
2561
2562
244
          if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2563
35
            zend_error(
2564
35
              E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
2565
35
              " by unpacking a Traversable, passing by-value instead", arg_num,
2566
35
              EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
2567
35
              EX(call)->func->common.scope ? "::" : "",
2568
35
              ZSTR_VAL(EX(call)->func->common.function_name)
2569
35
            );
2570
35
            ZVAL_NEW_REF(top, arg);
2571
209
          } else {
2572
209
            ZVAL_COPY_VALUE(top, arg);
2573
209
          }
2574
2575
244
          ZEND_CALL_NUM_ARGS(EX(call))++;
2576
244
        }
2577
2578
344
        funcs->move_forward(iter);
2579
344
      }
2580
2581
172
      zend_iterator_dtor(iter);
2582
172
    }
2583
193
  } else if (EXPECTED(Z_ISREF_P(args))) {
2584
0
    args = Z_REFVAL_P(args);
2585
0
    goto send_again;
2586
34
  } else {
2587
34
    if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(args) == IS_UNDEF)) {
2588
7
      ZVAL_UNDEFINED_OP1();
2589
7
    }
2590
34
    zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(args));
2591
34
  }
2592
2593
1.67k
  FREE_OP(opline->op1_type, opline->op1.var);
2594
1.67k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2595
1.67k
}
2596
2597
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2598
1.04k
{
2599
1.04k
  USE_OPLINE
2600
1.04k
  zval *args;
2601
2602
1.04k
  SAVE_OPLINE();
2603
1.04k
  args = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2604
2605
1.04k
  if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) {
2606
27
    if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) {
2607
0
      args = Z_REFVAL_P(args);
2608
0
      if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
2609
0
        goto send_array;
2610
0
      }
2611
0
    }
2612
27
    zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_zval_value_name(args));
2613
27
    FREE_OP(opline->op2_type, opline->op2.var);
2614
27
    FREE_OP(opline->op1_type, opline->op1.var);
2615
27
    HANDLE_EXCEPTION();
2616
1.01k
  } else {
2617
1.01k
    uint32_t arg_num;
2618
1.01k
    HashTable *ht;
2619
1.01k
    zval *arg, *param;
2620
2621
1.01k
send_array:
2622
1.01k
    ht = Z_ARRVAL_P(args);
2623
1.01k
    if (opline->op2_type != IS_UNUSED) {
2624
      /* We don't need to handle named params in this case,
2625
       * because array_slice() is called with $preserve_keys == false. */
2626
70
      zval *op2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
2627
70
      uint32_t skip = opline->extended_value;
2628
70
      uint32_t count = zend_hash_num_elements(ht);
2629
70
      zend_long len;
2630
70
      if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
2631
0
        len = Z_LVAL_P(op2);
2632
70
      } else if (Z_TYPE_P(op2) == IS_NULL) {
2633
21
        len = count - skip;
2634
49
      } else if (EX_USES_STRICT_TYPES()
2635
49
          || !zend_parse_arg_long_weak(op2, &len, /* arg_num */ 3)) {
2636
39
        zend_type_error(
2637
39
          "array_slice(): Argument #3 ($length) must be of type ?int, %s given",
2638
39
          zend_zval_value_name(op2));
2639
39
        FREE_OP(opline->op2_type, opline->op2.var);
2640
39
        FREE_OP(opline->op1_type, opline->op1.var);
2641
39
        HANDLE_EXCEPTION();
2642
39
      }
2643
2644
31
      if (len < 0) {
2645
0
        len += (zend_long)(count - skip);
2646
0
      }
2647
31
      if (skip < count && len > 0) {
2648
24
        if (len > (zend_long)(count - skip)) {
2649
0
          len = (zend_long)(count - skip);
2650
0
        }
2651
24
        zend_vm_stack_extend_call_frame(&EX(call), 0, len);
2652
24
        arg_num = 1;
2653
24
        param = ZEND_CALL_ARG(EX(call), 1);
2654
168
        ZEND_HASH_FOREACH_VAL(ht, arg) {
2655
168
          bool must_wrap = 0;
2656
168
          if (skip > 0) {
2657
13
            skip--;
2658
13
            continue;
2659
59
          } else if ((zend_long)(arg_num - 1) >= len) {
2660
5
            break;
2661
54
          } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2662
0
            if (UNEXPECTED(!Z_ISREF_P(arg))) {
2663
0
              if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2664
                /* By-value send is not allowed -- emit a warning,
2665
                 * but still perform the call. */
2666
0
                zend_param_must_be_ref(EX(call)->func, arg_num);
2667
0
                must_wrap = 1;
2668
0
              }
2669
0
            }
2670
54
          } else {
2671
54
            if (Z_ISREF_P(arg) &&
2672
54
                !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
2673
              /* don't separate references for __call */
2674
0
              arg = Z_REFVAL_P(arg);
2675
0
            }
2676
54
          }
2677
54
          if (EXPECTED(!must_wrap)) {
2678
54
            ZVAL_COPY(param, arg);
2679
54
          } else {
2680
0
            Z_TRY_ADDREF_P(arg);
2681
0
            ZVAL_NEW_REF(param, arg);
2682
0
          }
2683
54
          ZEND_CALL_NUM_ARGS(EX(call))++;
2684
54
          arg_num++;
2685
54
          param++;
2686
54
        } ZEND_HASH_FOREACH_END();
2687
24
      }
2688
31
      FREE_OP(opline->op2_type, opline->op2.var);
2689
949
    } else {
2690
949
      zend_string *name;
2691
949
      bool have_named_params;
2692
949
      zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
2693
949
      arg_num = 1;
2694
949
      param = ZEND_CALL_ARG(EX(call), 1);
2695
949
      have_named_params = 0;
2696
1.31M
      ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2697
1.31M
        if (name) {
2698
48
          void *cache_slot[2] = {NULL, NULL};
2699
48
          have_named_params = 1;
2700
48
          param = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2701
48
          if (!param) {
2702
13
            FREE_OP(opline->op1_type, opline->op1.var);
2703
13
            HANDLE_EXCEPTION();
2704
13
          }
2705
655k
        } else if (have_named_params) {
2706
7
          zend_throw_error(NULL,
2707
7
            "Cannot use positional argument after named argument");
2708
7
          FREE_OP(opline->op1_type, opline->op1.var);
2709
7
          HANDLE_EXCEPTION();
2710
7
        }
2711
2712
655k
        bool must_wrap = 0;
2713
655k
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2714
216
          if (UNEXPECTED(!Z_ISREF_P(arg))) {
2715
134
            if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2716
              /* By-value send is not allowed -- emit a warning,
2717
               * but still perform the call. */
2718
86
              zend_param_must_be_ref(EX(call)->func, arg_num);
2719
86
              must_wrap = 1;
2720
86
            }
2721
134
          }
2722
655k
        } else {
2723
655k
          if (Z_ISREF_P(arg) &&
2724
655k
              !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
2725
            /* don't separate references for __call */
2726
20
            arg = Z_REFVAL_P(arg);
2727
20
          }
2728
655k
        }
2729
2730
655k
        if (EXPECTED(!must_wrap)) {
2731
655k
          ZVAL_COPY(param, arg);
2732
655k
        } else {
2733
86
          Z_TRY_ADDREF_P(arg);
2734
86
          ZVAL_NEW_REF(param, arg);
2735
86
        }
2736
655k
        if (!name) {
2737
655k
          ZEND_CALL_NUM_ARGS(EX(call))++;
2738
655k
          arg_num++;
2739
655k
          param++;
2740
655k
        }
2741
655k
      } ZEND_HASH_FOREACH_END();
2742
949
    }
2743
1.01k
  }
2744
960
  FREE_OP(opline->op1_type, opline->op1.var);
2745
960
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2746
960
}
2747
2748
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
2749
330
{
2750
330
  USE_OPLINE
2751
2752
330
  SAVE_OPLINE();
2753
2754
330
  zend_missing_arg_error(execute_data);
2755
330
  HANDLE_EXCEPTION();
2756
330
}
2757
2758
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_verify_recv_arg_type_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1)
2759
3.46k
{
2760
3.46k
  USE_OPLINE
2761
2762
3.46k
  SAVE_OPLINE();
2763
3.46k
  if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), opline->op1.num, op_1))) {
2764
582
    HANDLE_EXCEPTION();
2765
582
  }
2766
2767
2.88k
  ZEND_VM_NEXT_OPCODE();
2768
2.88k
}
2769
2770
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2771
1.33k
{
2772
1.33k
  USE_OPLINE
2773
1.33k
  uint32_t arg_num = opline->op1.num;
2774
2775
1.33k
  if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
2776
241
    ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
2777
241
  }
2778
2779
1.09k
  ZEND_VM_NEXT_OPCODE();
2780
1.09k
}
2781
2782
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2)
2783
62
{
2784
62
  int ret;
2785
62
  USE_OPLINE
2786
2787
62
  SAVE_OPLINE();
2788
62
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
2789
0
    op_1 = ZVAL_UNDEFINED_OP1();
2790
0
  }
2791
62
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
2792
0
    op_2 = ZVAL_UNDEFINED_OP2();
2793
0
  }
2794
62
  ret = zend_compare(op_1, op_2);
2795
62
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
2796
0
    zval_ptr_dtor_nogc(op_2);
2797
0
  }
2798
62
  ZEND_VM_SMART_BRANCH(ret == 0, 1);
2799
62
}
2800
2801
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2802
221
{
2803
221
  USE_OPLINE
2804
221
  zval *op1;
2805
221
  HashTable *result_ht;
2806
2807
221
  SAVE_OPLINE();
2808
221
  op1 = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2809
221
  result_ht = Z_ARRVAL_P(EX_VAR(opline->result.var));
2810
2811
221
add_unpack_again:
2812
221
  if (EXPECTED(Z_TYPE_P(op1) == IS_ARRAY)) {
2813
128
    HashTable *ht = Z_ARRVAL_P(op1);
2814
128
    zval *val;
2815
2816
128
    if (HT_IS_PACKED(ht) && (zend_hash_num_elements(result_ht) == 0 || HT_IS_PACKED(result_ht))) {
2817
113
      zend_hash_extend(result_ht, result_ht->nNumUsed + zend_hash_num_elements(ht), 1);
2818
113
      ZEND_HASH_FILL_PACKED(result_ht) {
2819
630
        ZEND_HASH_PACKED_FOREACH_VAL(ht, val) {
2820
630
          if (UNEXPECTED(Z_ISREF_P(val)) &&
2821
202
            UNEXPECTED(Z_REFCOUNT_P(val) == 1)) {
2822
59
            val = Z_REFVAL_P(val);
2823
59
          }
2824
630
          Z_TRY_ADDREF_P(val);
2825
630
          ZEND_HASH_FILL_ADD(val);
2826
630
        } ZEND_HASH_FOREACH_END();
2827
113
      } ZEND_HASH_FILL_END();
2828
113
    } else {
2829
15
      zend_string *key;
2830
2831
75
      ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
2832
75
        if (UNEXPECTED(Z_ISREF_P(val)) &&
2833
30
          UNEXPECTED(Z_REFCOUNT_P(val) == 1)) {
2834
0
          val = Z_REFVAL_P(val);
2835
0
        }
2836
75
        Z_TRY_ADDREF_P(val);
2837
75
        if (key) {
2838
0
          zend_hash_update(result_ht, key, val);
2839
30
        } else {
2840
30
          if (!zend_hash_next_index_insert(result_ht, val)) {
2841
15
            zend_cannot_add_element();
2842
15
            zval_ptr_dtor_nogc(val);
2843
15
            break;
2844
15
          }
2845
30
        }
2846
75
      } ZEND_HASH_FOREACH_END();
2847
15
    }
2848
128
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
2849
85
    zend_class_entry *ce = Z_OBJCE_P(op1);
2850
85
    zend_object_iterator *iter;
2851
2852
85
    if (!ce || !ce->get_iterator) {
2853
0
      zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(op1));
2854
85
    } else {
2855
85
      iter = ce->get_iterator(ce, op1, 0);
2856
85
      if (UNEXPECTED(!iter)) {
2857
0
        FREE_OP(opline->op1_type, opline->op1.var);
2858
0
        if (!EG(exception)) {
2859
0
          zend_throw_exception_ex(
2860
0
            NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
2861
0
          );
2862
0
        }
2863
0
        HANDLE_EXCEPTION();
2864
0
      }
2865
2866
85
      const zend_object_iterator_funcs *funcs = iter->funcs;
2867
85
      if (funcs->rewind) {
2868
85
        funcs->rewind(iter);
2869
85
      }
2870
2871
228
      for (; funcs->valid(iter) == SUCCESS; ) {
2872
201
        zval *val;
2873
2874
201
        if (UNEXPECTED(EG(exception) != NULL)) {
2875
0
          break;
2876
0
        }
2877
2878
201
        val = funcs->get_current_data(iter);
2879
201
        if (UNEXPECTED(EG(exception) != NULL)) {
2880
0
          break;
2881
0
        }
2882
2883
201
        zval key;
2884
201
        if (funcs->get_current_key) {
2885
201
          funcs->get_current_key(iter, &key);
2886
201
          if (UNEXPECTED(EG(exception) != NULL)) {
2887
0
            break;
2888
0
          }
2889
2890
201
          if (UNEXPECTED(Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING)) {
2891
58
            zend_throw_error(NULL,
2892
58
              "Keys must be of type int|string during array unpacking");
2893
58
            zval_ptr_dtor(&key);
2894
58
            break;
2895
58
          }
2896
201
        } else {
2897
0
          ZVAL_UNDEF(&key);
2898
0
        }
2899
2900
143
        ZVAL_DEREF(val);
2901
143
        Z_TRY_ADDREF_P(val);
2902
2903
143
        zend_ulong num_key;
2904
143
        if (Z_TYPE(key) == IS_STRING && !ZEND_HANDLE_NUMERIC(Z_STR(key), num_key)) {
2905
0
          zend_hash_update(result_ht, Z_STR(key), val);
2906
0
          zval_ptr_dtor_str(&key);
2907
143
        } else {
2908
143
          zval_ptr_dtor(&key);
2909
143
          if (!zend_hash_next_index_insert(result_ht, val)) {
2910
0
            zend_cannot_add_element();
2911
0
            zval_ptr_dtor_nogc(val);
2912
0
            break;
2913
0
          }
2914
143
        }
2915
2916
143
        funcs->move_forward(iter);
2917
143
        if (UNEXPECTED(EG(exception))) {
2918
0
          break;
2919
0
        }
2920
143
      }
2921
2922
85
      zend_iterator_dtor(iter);
2923
85
    }
2924
85
  } else if (EXPECTED(Z_ISREF_P(op1))) {
2925
0
    op1 = Z_REFVAL_P(op1);
2926
0
    goto add_unpack_again;
2927
8
  } else {
2928
8
    zend_throw_error(NULL, "Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(op1));
2929
8
  }
2930
2931
221
  FREE_OP(opline->op1_type, opline->op1.var);
2932
221
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2933
221
}
2934
2935
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2936
17
{
2937
17
  USE_OPLINE
2938
17
  zval *varname;
2939
17
  zend_string *name, *tmp_name = NULL;
2940
17
  zend_class_entry *ce;
2941
2942
17
  SAVE_OPLINE();
2943
2944
17
  if (opline->op2_type == IS_CONST) {
2945
10
    ce = CACHED_PTR(opline->extended_value);
2946
10
    if (UNEXPECTED(ce == NULL)) {
2947
10
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
2948
10
      if (UNEXPECTED(ce == NULL)) {
2949
5
        FREE_OP(opline->op1_type, opline->op1.var);
2950
5
        HANDLE_EXCEPTION();
2951
5
      }
2952
      /*CACHE_PTR(opline->extended_value, ce);*/
2953
10
    }
2954
10
  } else if (opline->op2_type == IS_UNUSED) {
2955
7
    ce = zend_fetch_class(NULL, opline->op2.num);
2956
7
    if (UNEXPECTED(ce == NULL)) {
2957
7
      FREE_OP(opline->op1_type, opline->op1.var);
2958
7
      HANDLE_EXCEPTION();
2959
7
    }
2960
7
  } else {
2961
0
    ce = Z_CE_P(EX_VAR(opline->op2.var));
2962
0
  }
2963
2964
5
  varname = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
2965
5
  if (opline->op1_type == IS_CONST) {
2966
5
    name = Z_STR_P(varname);
2967
5
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
2968
0
    name = Z_STR_P(varname);
2969
0
  } else {
2970
0
    if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
2971
0
      varname = ZVAL_UNDEFINED_OP1();
2972
0
    }
2973
0
    name = zval_try_get_tmp_string(varname, &tmp_name);
2974
0
    if (UNEXPECTED(!name)) {
2975
0
      FREE_OP(opline->op1_type, opline->op1.var);
2976
0
      HANDLE_EXCEPTION();
2977
0
    }
2978
0
  }
2979
2980
5
  zend_std_unset_static_property(ce, name);
2981
2982
5
  zend_tmp_string_release(tmp_name);
2983
5
  FREE_OP(opline->op1_type, opline->op1.var);
2984
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2985
5
}
2986
2987
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
2988
3.98k
{
2989
3.98k
  USE_OPLINE
2990
3.98k
  zval *array;
2991
3.98k
  zval *value;
2992
3.98k
  uint32_t value_type;
2993
3.98k
  HashTable *fe_ht;
2994
3.98k
  HashPosition pos;
2995
3.98k
  Bucket *p;
2996
3.98k
  zend_object_iterator *iter;
2997
2998
3.98k
  array = EX_VAR(opline->op1.var);
2999
3.98k
  SAVE_OPLINE();
3000
3001
3.98k
  ZEND_ASSERT(Z_TYPE_P(array) == IS_OBJECT);
3002
3.98k
  if ((iter = zend_iterator_unwrap(array)) == NULL) {
3003
    /* plain object */
3004
3005
663
    fe_ht = Z_OBJPROP_P(array);
3006
663
    pos = zend_hash_iterator_pos(Z_FE_ITER_P(array), fe_ht);
3007
663
    p = fe_ht->arData + pos;
3008
828
    while (1) {
3009
828
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
3010
        /* reached end of iteration */
3011
162
        goto fe_fetch_r_exit;
3012
162
      }
3013
666
      pos++;
3014
666
      value = &p->val;
3015
666
      value_type = Z_TYPE_INFO_P(value);
3016
666
      if (EXPECTED(value_type != IS_UNDEF)) {
3017
530
        if (UNEXPECTED(value_type == IS_INDIRECT)) {
3018
140
          value = Z_INDIRECT_P(value);
3019
140
          value_type = Z_TYPE_INFO_P(value);
3020
140
          if (EXPECTED(value_type != IS_UNDEF)
3021
140
           && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
3022
116
            break;
3023
116
          }
3024
390
        } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
3025
390
            || !p->key
3026
390
            || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
3027
385
          break;
3028
385
        }
3029
530
      }
3030
165
      p++;
3031
165
    }
3032
501
    EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos;
3033
501
    if (RETURN_VALUE_USED(opline)) {
3034
148
      if (UNEXPECTED(!p->key)) {
3035
0
        ZVAL_LONG(EX_VAR(opline->result.var), p->h);
3036
148
      } else if (ZSTR_VAL(p->key)[0]) {
3037
110
        ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
3038
110
      } else {
3039
38
        const char *class_name, *prop_name;
3040
38
        size_t prop_name_len;
3041
38
        zend_unmangle_property_name_ex(
3042
38
          p->key, &class_name, &prop_name, &prop_name_len);
3043
38
        ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
3044
38
      }
3045
148
    }
3046
3.31k
  } else {
3047
3.31k
    const zend_object_iterator_funcs *funcs = iter->funcs;
3048
3.31k
    if (EXPECTED(++iter->index > 0)) {
3049
      /* This could cause an endless loop if index becomes zero again.
3050
       * In case that ever happens we need an additional flag. */
3051
2.24k
      funcs->move_forward(iter);
3052
2.24k
      if (UNEXPECTED(EG(exception) != NULL)) {
3053
63
        UNDEF_RESULT();
3054
63
        HANDLE_EXCEPTION();
3055
63
      }
3056
2.18k
      if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
3057
        /* reached end of iteration */
3058
807
        if (UNEXPECTED(EG(exception) != NULL)) {
3059
4
          UNDEF_RESULT();
3060
4
          HANDLE_EXCEPTION();
3061
4
        }
3062
965
fe_fetch_r_exit:
3063
965
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
3064
965
        ZEND_VM_CONTINUE();
3065
965
      }
3066
2.18k
    }
3067
2.44k
    value = funcs->get_current_data(iter);
3068
2.44k
    if (UNEXPECTED(EG(exception) != NULL)) {
3069
43
      UNDEF_RESULT();
3070
43
      HANDLE_EXCEPTION();
3071
43
    }
3072
2.40k
    if (!value) {
3073
      /* failure in get_current_data */
3074
0
      goto fe_fetch_r_exit;
3075
0
    }
3076
2.40k
    if (RETURN_VALUE_USED(opline)) {
3077
704
      if (funcs->get_current_key) {
3078
704
        funcs->get_current_key(iter, EX_VAR(opline->result.var));
3079
704
        if (UNEXPECTED(EG(exception) != NULL)) {
3080
35
          UNDEF_RESULT();
3081
35
          HANDLE_EXCEPTION();
3082
35
        }
3083
704
      } else {
3084
0
        ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
3085
0
      }
3086
704
    }
3087
2.36k
    value_type = Z_TYPE_INFO_P(value);
3088
2.36k
  }
3089
3090
2.87k
  if (EXPECTED(opline->op2_type == IS_CV)) {
3091
2.85k
    zval *variable_ptr = EX_VAR(opline->op2.var);
3092
2.85k
    zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
3093
2.85k
  } else {
3094
19
    zval *res = EX_VAR(opline->op2.var);
3095
19
    zend_refcounted *gc = Z_COUNTED_P(value);
3096
3097
19
    ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
3098
19
    if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
3099
0
      GC_ADDREF(gc);
3100
0
    }
3101
19
  }
3102
2.87k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3103
2.87k
}
3104
3105
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3106
292
{
3107
292
  USE_OPLINE
3108
292
  zval *value;
3109
292
  bool result;
3110
3111
292
  SAVE_OPLINE();
3112
3113
292
  value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
3114
3115
292
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
3116
292
    result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
3117
292
        (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
3118
292
  } else {
3119
0
    result = value == NULL || !i_zend_is_true(value);
3120
0
  }
3121
3122
292
  ZEND_VM_SMART_BRANCH(result, 1);
3123
292
}
3124
3125
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3126
23.9k
{
3127
23.9k
  USE_OPLINE
3128
3129
23.9k
  ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
3130
3131
23.9k
  if (!E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))) {
3132
191
    do {
3133
      /* Do not silence fatal errors */
3134
191
      EG(error_reporting) &= E_FATAL_ERRORS;
3135
191
      if (!EG(error_reporting_ini_entry)) {
3136
0
        zval *zv = zend_hash_find_known_hash(EG(ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING));
3137
0
        if (zv) {
3138
0
          EG(error_reporting_ini_entry) = (zend_ini_entry *)Z_PTR_P(zv);
3139
0
        } else {
3140
0
          break;
3141
0
        }
3142
0
      }
3143
191
      if (!EG(error_reporting_ini_entry)->modified) {
3144
0
        if (!EG(modified_ini_directives)) {
3145
0
          ALLOC_HASHTABLE(EG(modified_ini_directives));
3146
0
          zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
3147
0
        }
3148
0
        if (EXPECTED(zend_hash_add_ptr(EG(modified_ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING), EG(error_reporting_ini_entry)) != NULL)) {
3149
0
          EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
3150
0
          EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
3151
0
          EG(error_reporting_ini_entry)->modified = 1;
3152
0
        }
3153
0
      }
3154
191
    } while (0);
3155
191
  }
3156
23.9k
  ZEND_VM_NEXT_OPCODE();
3157
23.9k
}
3158
3159
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3160
0
{
3161
0
  USE_OPLINE
3162
3163
0
  if (!EG(no_extensions)) {
3164
0
    SAVE_OPLINE();
3165
0
    zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, execute_data);
3166
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3167
0
  }
3168
0
  ZEND_VM_NEXT_OPCODE();
3169
0
}
3170
3171
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3172
0
{
3173
0
  USE_OPLINE
3174
3175
0
  if (!EG(no_extensions)) {
3176
0
    SAVE_OPLINE();
3177
0
    zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, execute_data);
3178
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3179
0
  }
3180
0
  ZEND_VM_NEXT_OPCODE();
3181
0
}
3182
3183
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3184
0
{
3185
0
  USE_OPLINE
3186
3187
0
  if (!EG(no_extensions)) {
3188
0
    SAVE_OPLINE();
3189
0
    zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, execute_data);
3190
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3191
0
  }
3192
0
  ZEND_VM_NEXT_OPCODE();
3193
0
}
3194
3195
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3196
913
{
3197
913
  zval *zv;
3198
913
  zend_class_entry *ce;
3199
913
  USE_OPLINE
3200
3201
913
  ce = CACHED_PTR(opline->extended_value);
3202
913
  if (UNEXPECTED(ce == NULL)) {
3203
812
    zend_string *rtd_key = Z_STR_P(RT_CONSTANT(opline, opline->op1));
3204
812
    zv = zend_hash_find_known_hash(EG(class_table), rtd_key);
3205
812
    ZEND_ASSERT(zv != NULL);
3206
812
    ce = Z_CE_P(zv);
3207
812
    if (!(ce->ce_flags & ZEND_ACC_LINKED)) {
3208
192
      SAVE_OPLINE();
3209
192
      ce = zend_do_link_class(ce, (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL, rtd_key);
3210
192
      if (!ce) {
3211
3
        HANDLE_EXCEPTION();
3212
3
      }
3213
192
    }
3214
809
    CACHE_PTR(opline->extended_value, ce);
3215
809
  }
3216
910
  Z_CE_P(EX_VAR(opline->result.var)) = ce;
3217
910
  ZEND_VM_NEXT_OPCODE();
3218
910
}
3219
3220
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3221
81
{
3222
81
  zend_function *func;
3223
81
  USE_OPLINE
3224
3225
81
  SAVE_OPLINE();
3226
81
  func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
3227
81
  do_bind_function(func, RT_CONSTANT(opline, opline->op1));
3228
81
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3229
81
}
3230
3231
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3232
401
{
3233
401
  USE_OPLINE
3234
3235
401
  if ((uint32_t)++EG(ticks_count) >= opline->extended_value) {
3236
257
    EG(ticks_count) = 0;
3237
257
    if (zend_ticks_function) {
3238
257
      SAVE_OPLINE();
3239
257
      zend_fiber_switch_block();
3240
257
      zend_ticks_function(opline->extended_value);
3241
257
      zend_fiber_switch_unblock();
3242
257
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3243
257
    }
3244
257
  }
3245
144
  ZEND_VM_NEXT_OPCODE();
3246
144
}
3247
3248
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3249
0
{
3250
0
  USE_OPLINE
3251
3252
0
  ZEND_VM_NEXT_OPCODE();
3253
0
}
3254
3255
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3256
7.15k
{
3257
7.15k
  USE_OPLINE
3258
3259
7.15k
  ZEND_VM_NEXT_OPCODE();
3260
7.15k
}
3261
3262
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX uint32_t try_catch_offset, uint32_t op_num)
3263
922k
{
3264
  /* May be NULL during generator closing (only finally blocks are executed) */
3265
922k
  zend_object *ex = EG(exception);
3266
3267
  /* Walk try/catch/finally structures upwards, performing the necessary actions */
3268
923k
  for (; try_catch_offset != (uint32_t) -1; try_catch_offset--) {
3269
614k
    zend_try_catch_element *try_catch =
3270
614k
      &EX(func)->op_array.try_catch_array[try_catch_offset];
3271
3272
614k
    if (op_num < try_catch->catch_op && ex) {
3273
      /* Go to catch block */
3274
614k
      cleanup_live_vars(execute_data, op_num, try_catch->catch_op);
3275
614k
      ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->catch_op], 0);
3276
3277
614k
    } else if (op_num < try_catch->finally_op) {
3278
339
      if (ex && zend_is_unwind_exit(ex)) {
3279
        /* Don't execute finally blocks on exit (for now) */
3280
10
        continue;
3281
10
      }
3282
3283
      /* Go to finally block */
3284
329
      zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
3285
329
      cleanup_live_vars(execute_data, op_num, try_catch->finally_op);
3286
329
      Z_OBJ_P(fast_call) = EG(exception);
3287
329
      EG(exception) = NULL;
3288
329
      Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1;
3289
329
      ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->finally_op], 0);
3290
3291
329
    } else if (op_num < try_catch->finally_end) {
3292
266
      zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
3293
3294
      /* cleanup incomplete RETURN statement */
3295
266
      if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
3296
266
       && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
3297
40
        zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
3298
3299
40
        zval_ptr_dtor(return_value);
3300
40
      }
3301
3302
      /* Chain potential exception from wrapping finally block */
3303
266
      if (Z_OBJ_P(fast_call)) {
3304
134
        if (ex) {
3305
129
          if (zend_is_unwind_exit(ex) || zend_is_graceful_exit(ex)) {
3306
            /* discard the previously thrown exception */
3307
10
            OBJ_RELEASE(Z_OBJ_P(fast_call));
3308
119
          } else {
3309
119
            zend_exception_set_previous(ex, Z_OBJ_P(fast_call));
3310
119
          }
3311
129
        } else {
3312
5
          ex = EG(exception) = Z_OBJ_P(fast_call);
3313
5
        }
3314
134
      }
3315
266
    }
3316
614k
  }
3317
3318
  /* Uncaught exception */
3319
3320
  /* Don't use 0 because it gets replaced by zend_vm_gen.php. */
3321
308k
  if (zend_observer_fcall_op_array_extension != -1) {
3322
0
    zend_observer_fcall_end(execute_data, NULL);
3323
0
  }
3324
308k
  cleanup_live_vars(execute_data, op_num, 0);
3325
308k
  if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
3326
671
    zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
3327
671
    EG(current_execute_data) = EX(prev_execute_data);
3328
671
    zend_generator_close(generator, 1);
3329
671
    ZEND_VM_RETURN();
3330
307k
  } else {
3331
    /* We didn't execute RETURN, and have to initialize return_value */
3332
307k
    if (EX(return_value)) {
3333
273k
      ZVAL_UNDEF(EX(return_value));
3334
273k
    }
3335
307k
    ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3336
307k
  }
3337
308k
}
3338
3339
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3340
922k
{
3341
922k
  const zend_op *throw_op = EG(opline_before_exception);
3342
3343
  /* Exception was thrown before executing any op */
3344
922k
  if (UNEXPECTED(!throw_op)) {
3345
2
    ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX -1, 0));
3346
2
  }
3347
3348
922k
  uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes;
3349
922k
  int i, current_try_catch_offset = -1;
3350
3351
922k
  if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE)
3352
922k
    && throw_op->extended_value & ZEND_FREE_ON_RETURN) {
3353
    /* exceptions thrown because of loop var destruction on return/break/...
3354
     * are logically thrown at the end of the foreach loop, so adjust the
3355
     * throw_op_num.
3356
     */
3357
32
    const zend_live_range *range = find_live_range(
3358
32
      &EX(func)->op_array, throw_op_num, throw_op->op1.var);
3359
    /* free op1 of the corresponding RETURN */
3360
69
    for (i = throw_op_num; i < range->end; i++) {
3361
69
      if (EX(func)->op_array.opcodes[i].opcode == ZEND_FREE
3362
69
       || EX(func)->op_array.opcodes[i].opcode == ZEND_FE_FREE) {
3363
        /* pass */
3364
37
      } else {
3365
32
        if (EX(func)->op_array.opcodes[i].opcode == ZEND_RETURN
3366
32
         && (EX(func)->op_array.opcodes[i].op1_type & (IS_VAR|IS_TMP_VAR))) {
3367
12
          zval_ptr_dtor(EX_VAR(EX(func)->op_array.opcodes[i].op1.var));
3368
12
        }
3369
32
        break;
3370
32
      }
3371
69
    }
3372
32
    throw_op_num = range->end;
3373
32
  }
3374
3375
  /* Find the innermost try/catch/finally the exception was thrown in */
3376
1.84M
  for (i = 0; i < EX(func)->op_array.last_try_catch; i++) {
3377
962k
    zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i];
3378
962k
    if (try_catch->try_op > throw_op_num) {
3379
      /* further blocks will not be relevant... */
3380
41.4k
      break;
3381
41.4k
    }
3382
921k
    if (throw_op_num < try_catch->catch_op || throw_op_num < try_catch->finally_end) {
3383
615k
      current_try_catch_offset = i;
3384
615k
    }
3385
921k
  }
3386
3387
922k
  cleanup_unfinished_calls(execute_data, throw_op_num);
3388
3389
922k
  if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
3390
49.6k
    switch (throw_op->opcode) {
3391
25
      case ZEND_ADD_ARRAY_ELEMENT:
3392
106
      case ZEND_ADD_ARRAY_UNPACK:
3393
126
      case ZEND_ROPE_INIT:
3394
393
      case ZEND_ROPE_ADD:
3395
393
        break; /* exception while building structures, live range handling will free those */
3396
3397
68
      case ZEND_FETCH_CLASS:
3398
71
      case ZEND_DECLARE_ANON_CLASS:
3399
71
        break; /* return value is zend_class_entry pointer */
3400
3401
49.2k
      default:
3402
        /* smart branch opcodes may not initialize result */
3403
49.2k
        if (!zend_is_smart_branch(throw_op)) {
3404
49.0k
          zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
3405
49.0k
        }
3406
49.6k
    }
3407
49.6k
  }
3408
3409
922k
  ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX current_try_catch_offset, throw_op_num));
3410
922k
}
3411
3412
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3413
0
{
3414
0
  USE_OPLINE
3415
0
  int ret;
3416
3417
0
  SAVE_OPLINE();
3418
0
  ret = zend_user_opcode_handlers[opline->opcode](execute_data);
3419
0
  opline = EX(opline);
3420
3421
0
  switch (ret) {
3422
0
    case ZEND_USER_OPCODE_CONTINUE:
3423
0
      ZEND_VM_CONTINUE();
3424
0
    case ZEND_USER_OPCODE_RETURN:
3425
0
      if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
3426
0
        zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
3427
0
        EG(current_execute_data) = EX(prev_execute_data);
3428
0
        zend_generator_close(generator, 1);
3429
0
        ZEND_VM_RETURN();
3430
0
      } else {
3431
0
        ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3432
0
      }
3433
0
    case ZEND_USER_OPCODE_ENTER:
3434
0
      ZEND_VM_ENTER();
3435
0
    case ZEND_USER_OPCODE_LEAVE:
3436
0
      ZEND_VM_LEAVE();
3437
0
    case ZEND_USER_OPCODE_DISPATCH:
3438
0
      ZEND_VM_DISPATCH(opline->opcode, opline);
3439
0
    default:
3440
0
      ZEND_VM_DISPATCH((uint8_t)(ret & 0xff), opline);
3441
0
  }
3442
0
}
3443
3444
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
3445
5
{
3446
5
  USE_OPLINE
3447
3448
5
  SAVE_OPLINE();
3449
5
  zend_throw_error(NULL, "Cannot yield from finally in a force-closed generator");
3450
5
  FREE_OP(opline->op2_type, opline->op2.var);
3451
5
  FREE_OP(opline->op1_type, opline->op1.var);
3452
5
  UNDEF_RESULT();
3453
5
  HANDLE_EXCEPTION();
3454
5
}
3455
3456
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3457
116
{
3458
116
  USE_OPLINE
3459
116
  zval *fast_call = EX_VAR(opline->op1.var);
3460
116
  SAVE_OPLINE();
3461
3462
  /* cleanup incomplete RETURN statement */
3463
116
  if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
3464
116
   && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
3465
15
    zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
3466
3467
15
    zval_ptr_dtor(return_value);
3468
15
  }
3469
3470
  /* cleanup delayed exception */
3471
116
  if (Z_OBJ_P(fast_call) != NULL) {
3472
    /* discard the previously thrown exception */
3473
22
    OBJ_RELEASE(Z_OBJ_P(fast_call));
3474
22
    Z_OBJ_P(fast_call) = NULL;
3475
22
  }
3476
3477
116
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3478
116
}
3479
3480
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3481
708
{
3482
708
  USE_OPLINE
3483
708
  zval *fast_call = EX_VAR(opline->result.var);
3484
3485
708
  Z_OBJ_P(fast_call) = NULL;
3486
  /* set return address */
3487
708
  Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.opcodes;
3488
708
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
3489
708
}
3490
3491
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3492
755
{
3493
755
  USE_OPLINE
3494
755
  zval *fast_call = EX_VAR(opline->op1.var);
3495
755
  uint32_t current_try_catch_offset, current_op_num;
3496
3497
755
  if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1) {
3498
527
    const zend_op *fast_ret = EX(func)->op_array.opcodes + Z_OPLINE_NUM_P(fast_call);
3499
3500
527
    ZEND_VM_JMP_EX(fast_ret + 1, 0);
3501
527
  }
3502
3503
  /* special case for unhandled exceptions */
3504
228
  EG(exception) = Z_OBJ_P(fast_call);
3505
228
  Z_OBJ_P(fast_call) = NULL;
3506
228
  current_try_catch_offset = opline->op2.num;
3507
228
  current_op_num = opline - EX(func)->op_array.opcodes;
3508
228
  ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX current_try_catch_offset, current_op_num));
3509
755
}
3510
3511
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3512
2.54k
{
3513
2.54k
  USE_OPLINE
3514
3515
2.54k
  if (EG(assertions) <= 0) {
3516
78
    zend_op *target = OP_JMP_ADDR(opline, opline->op2);
3517
78
    if (RETURN_VALUE_USED(opline)) {
3518
70
      ZVAL_TRUE(EX_VAR(opline->result.var));
3519
70
    }
3520
78
    ZEND_VM_JMP_EX(target, 0);
3521
2.47k
  } else {
3522
2.47k
    ZEND_VM_NEXT_OPCODE();
3523
2.47k
  }
3524
2.54k
}
3525
3526
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3527
2.99k
{
3528
2.99k
  zend_array *args = NULL;
3529
2.99k
  zend_function *fbc = EX(func);
3530
2.99k
  zval *ret = EX(return_value);
3531
2.99k
  uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
3532
2.99k
  uint32_t num_args = EX_NUM_ARGS();
3533
2.99k
  zend_execute_data *call;
3534
3535
2.99k
  SAVE_OPLINE();
3536
3537
2.99k
  if (num_args) {
3538
208
    zval *p = ZEND_CALL_ARG(execute_data, 1);
3539
208
    zval *end = p + num_args;
3540
3541
208
    args = zend_new_array(num_args);
3542
208
    zend_hash_real_init_packed(args);
3543
208
    ZEND_HASH_FILL_PACKED(args) {
3544
286
      do {
3545
286
        ZEND_HASH_FILL_ADD(p);
3546
286
        p++;
3547
286
      } while (p != end);
3548
208
    } ZEND_HASH_FILL_END();
3549
208
  }
3550
3551
2.99k
  call = execute_data;
3552
2.99k
  execute_data = EG(current_execute_data) = EX(prev_execute_data);
3553
3554
2.99k
  call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
3555
2.99k
  ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
3556
2.99k
  ZEND_CALL_NUM_ARGS(call) = 2;
3557
3558
2.99k
  ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
3559
3560
2.99k
  zval *call_args = ZEND_CALL_ARG(call, 2);
3561
2.99k
  if (args) {
3562
208
    ZVAL_ARR(call_args, args);
3563
2.78k
  } else {
3564
2.78k
    ZVAL_EMPTY_ARRAY(call_args);
3565
2.78k
  }
3566
2.99k
  if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3567
794
    if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
3568
781
      GC_ADDREF(call->extra_named_params);
3569
781
      ZVAL_ARR(call_args, call->extra_named_params);
3570
781
    } else {
3571
13
      SEPARATE_ARRAY(call_args);
3572
13
      zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
3573
13
    }
3574
794
  }
3575
2.99k
  zend_free_trampoline(fbc);
3576
2.99k
  fbc = call->func;
3577
3578
2.99k
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3579
2.99k
    if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3580
522
      init_func_run_time_cache(&fbc->op_array);
3581
522
    }
3582
2.99k
    execute_data = call;
3583
2.99k
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
3584
2.99k
    if (EXPECTED(zend_execute_ex == execute_ex)) {
3585
637
      LOAD_OPLINE_EX();
3586
3587
3588
637
      ZEND_VM_ENTER_EX();
3589
2.35k
    } else {
3590
2.35k
      SAVE_OPLINE_EX();
3591
3592
2.35k
      execute_data = EX(prev_execute_data);
3593
2.35k
      if (execute_data) {
3594
2.35k
        LOAD_OPLINE();
3595
2.35k
      }
3596
2.35k
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3597
2.35k
      zend_execute_ex(call);
3598
2.35k
    }
3599
2.99k
  } else {
3600
0
    zval retval;
3601
3602
0
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3603
3604
0
    EG(current_execute_data) = call;
3605
3606
0
#if ZEND_DEBUG
3607
0
    bool should_throw = zend_internal_call_should_throw(fbc, call);
3608
0
#endif
3609
3610
0
    if (ret == NULL) {
3611
0
      ret = &retval;
3612
0
    }
3613
3614
0
    ZVAL_NULL(ret);
3615
3616
0
    if (!zend_execute_internal) {
3617
      /* saves one function call if zend_execute_internal is not used */
3618
0
      fbc->internal_function.handler(call, ret);
3619
0
    } else {
3620
0
      zend_execute_internal(call, ret);
3621
0
    }
3622
3623
0
#if ZEND_DEBUG
3624
0
    if (!EG(exception) && call->func) {
3625
0
      if (should_throw) {
3626
0
        zend_internal_call_arginfo_violation(call->func);
3627
0
      }
3628
0
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3629
0
        zend_verify_internal_return_type(call->func, ret));
3630
0
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3631
0
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
3632
0
      zend_verify_internal_func_info(call->func, ret);
3633
0
    }
3634
0
#endif
3635
3636
0
    EG(current_execute_data) = call->prev_execute_data;
3637
3638
0
    zend_vm_stack_free_args(call);
3639
0
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3640
0
      zend_free_extra_named_params(call->extra_named_params);
3641
0
    }
3642
0
    if (ret == &retval) {
3643
0
      zval_ptr_dtor(ret);
3644
0
    }
3645
0
  }
3646
3647
2.35k
  execute_data = EG(current_execute_data);
3648
3649
2.35k
  if (!execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
3650
639
    ZEND_VM_RETURN();
3651
639
  }
3652
3653
1.71k
  if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
3654
0
    zend_object *object = Z_OBJ(call->This);
3655
0
    OBJ_RELEASE(object);
3656
0
  }
3657
1.71k
  zend_vm_stack_free_call_frame(call);
3658
3659
1.71k
  if (UNEXPECTED(EG(exception) != NULL)) {
3660
0
    zend_rethrow_exception(execute_data);
3661
0
    HANDLE_EXCEPTION_LEAVE();
3662
0
  }
3663
3664
1.71k
  LOAD_OPLINE();
3665
1.71k
  ZEND_VM_INC_OPCODE();
3666
1.71k
  ZEND_VM_LEAVE();
3667
1.71k
}
3668
3669
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3670
0
{
3671
0
  zend_array *args = NULL;
3672
0
  zend_function *fbc = EX(func);
3673
0
  zval *ret = EX(return_value);
3674
0
  uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
3675
0
  uint32_t num_args = EX_NUM_ARGS();
3676
0
  zend_execute_data *call;
3677
3678
0
  SAVE_OPLINE();
3679
3680
0
  if (num_args) {
3681
0
    zval *p = ZEND_CALL_ARG(execute_data, 1);
3682
0
    zval *end = p + num_args;
3683
3684
0
    args = zend_new_array(num_args);
3685
0
    zend_hash_real_init_packed(args);
3686
0
    ZEND_HASH_FILL_PACKED(args) {
3687
0
      do {
3688
0
        ZEND_HASH_FILL_ADD(p);
3689
0
        p++;
3690
0
      } while (p != end);
3691
0
    } ZEND_HASH_FILL_END();
3692
0
  }
3693
3694
0
  call = execute_data;
3695
0
  execute_data = EG(current_execute_data) = EX(prev_execute_data);
3696
3697
0
  call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
3698
0
  ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
3699
0
  ZEND_CALL_NUM_ARGS(call) = 2;
3700
3701
0
  ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
3702
3703
0
  zval *call_args = ZEND_CALL_ARG(call, 2);
3704
0
  if (args) {
3705
0
    ZVAL_ARR(call_args, args);
3706
0
  } else {
3707
0
    ZVAL_EMPTY_ARRAY(call_args);
3708
0
  }
3709
0
  if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3710
0
    if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
3711
0
      GC_ADDREF(call->extra_named_params);
3712
0
      ZVAL_ARR(call_args, call->extra_named_params);
3713
0
    } else {
3714
0
      SEPARATE_ARRAY(call_args);
3715
0
      zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
3716
0
    }
3717
0
  }
3718
0
  zend_free_trampoline(fbc);
3719
0
  fbc = call->func;
3720
3721
0
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3722
0
    if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3723
0
      init_func_run_time_cache(&fbc->op_array);
3724
0
    }
3725
0
    execute_data = call;
3726
0
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
3727
0
    if (EXPECTED(zend_execute_ex == execute_ex)) {
3728
0
      LOAD_OPLINE_EX();
3729
0
      SAVE_OPLINE();
3730
0
      zend_observer_fcall_begin_specialized(execute_data, false);
3731
0
      ZEND_VM_ENTER_EX();
3732
0
    } else {
3733
0
      SAVE_OPLINE_EX();
3734
0
      zend_observer_fcall_begin_specialized(execute_data, false);
3735
0
      execute_data = EX(prev_execute_data);
3736
0
      if (execute_data) {
3737
0
        LOAD_OPLINE();
3738
0
      }
3739
0
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3740
0
      zend_execute_ex(call);
3741
0
    }
3742
0
  } else {
3743
0
    zval retval;
3744
3745
0
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3746
3747
0
    EG(current_execute_data) = call;
3748
3749
0
#if ZEND_DEBUG
3750
0
    bool should_throw = zend_internal_call_should_throw(fbc, call);
3751
0
#endif
3752
3753
0
    if (ret == NULL) {
3754
0
      ret = &retval;
3755
0
    }
3756
3757
0
    ZVAL_NULL(ret);
3758
0
    zend_observer_fcall_begin_specialized(call, false);
3759
0
    if (!zend_execute_internal) {
3760
      /* saves one function call if zend_execute_internal is not used */
3761
0
      fbc->internal_function.handler(call, ret);
3762
0
    } else {
3763
0
      zend_execute_internal(call, ret);
3764
0
    }
3765
3766
0
#if ZEND_DEBUG
3767
0
    if (!EG(exception) && call->func) {
3768
0
      if (should_throw) {
3769
0
        zend_internal_call_arginfo_violation(call->func);
3770
0
      }
3771
0
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3772
0
        zend_verify_internal_return_type(call->func, ret));
3773
0
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3774
0
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
3775
0
      zend_verify_internal_func_info(call->func, ret);
3776
0
    }
3777
0
#endif
3778
0
    zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
3779
3780
0
    EG(current_execute_data) = call->prev_execute_data;
3781
3782
0
    zend_vm_stack_free_args(call);
3783
0
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3784
0
      zend_free_extra_named_params(call->extra_named_params);
3785
0
    }
3786
0
    if (ret == &retval) {
3787
0
      zval_ptr_dtor(ret);
3788
0
    }
3789
0
  }
3790
3791
0
  execute_data = EG(current_execute_data);
3792
3793
0
  if (!execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
3794
0
    ZEND_VM_RETURN();
3795
0
  }
3796
3797
0
  if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
3798
0
    zend_object *object = Z_OBJ(call->This);
3799
0
    OBJ_RELEASE(object);
3800
0
  }
3801
0
  zend_vm_stack_free_call_frame(call);
3802
3803
0
  if (UNEXPECTED(EG(exception) != NULL)) {
3804
0
    zend_rethrow_exception(execute_data);
3805
0
    HANDLE_EXCEPTION_LEAVE();
3806
0
  }
3807
3808
0
  LOAD_OPLINE();
3809
0
  ZEND_VM_INC_OPCODE();
3810
0
  ZEND_VM_LEAVE();
3811
0
}
3812
3813
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3814
0
{
3815
0
  USE_OPLINE
3816
0
  SAVE_OPLINE();
3817
3818
0
  zval *result = EX_VAR(opline->result.var);
3819
0
  ZVAL_NULL(result);
3820
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3821
0
  zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3822
0
  if (EG(exception)) {
3823
0
    FREE_OP(opline->op1_type, opline->op1.var);
3824
0
    FREE_OP(opline->op2_type, opline->op2.var);
3825
0
    HANDLE_EXCEPTION();
3826
0
  }
3827
3828
#if 0 || 0
3829
  if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3830
    zend_frameless_observed_call(execute_data);
3831
  } else
3832
#endif
3833
0
  {
3834
0
    zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline);
3835
0
    function(result, arg1, arg2);
3836
0
  }
3837
3838
0
  FREE_OP(opline->op1_type, opline->op1.var);
3839
  /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3840
0
  if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3841
0
    ZVAL_UNDEF(EX_VAR(opline->op1.var));
3842
0
  }
3843
0
  FREE_OP(opline->op2_type, opline->op2.var);
3844
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3845
0
}
3846
3847
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3848
0
{
3849
0
  USE_OPLINE
3850
0
  SAVE_OPLINE();
3851
3852
0
  zval *result = EX_VAR(opline->result.var);
3853
0
  ZVAL_NULL(result);
3854
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3855
0
  zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3856
0
  if (EG(exception)) {
3857
0
    FREE_OP(opline->op1_type, opline->op1.var);
3858
0
    FREE_OP(opline->op2_type, opline->op2.var);
3859
0
    HANDLE_EXCEPTION();
3860
0
  }
3861
3862
0
#if 0 || 1
3863
0
  if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3864
0
    zend_frameless_observed_call(execute_data);
3865
0
  } else
3866
0
#endif
3867
0
  {
3868
0
    zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline);
3869
0
    function(result, arg1, arg2);
3870
0
  }
3871
3872
0
  FREE_OP(opline->op1_type, opline->op1.var);
3873
  /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3874
0
  if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3875
0
    ZVAL_UNDEF(EX_VAR(opline->op1.var));
3876
0
  }
3877
0
  FREE_OP(opline->op2_type, opline->op2.var);
3878
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3879
0
}
3880
3881
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3882
0
{
3883
0
  USE_OPLINE
3884
0
  SAVE_OPLINE();
3885
3886
0
  zval *result = EX_VAR(opline->result.var);
3887
0
  ZVAL_NULL(result);
3888
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3889
0
  zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3890
0
  zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1);
3891
0
  if (EG(exception)) {
3892
0
    FREE_OP(opline->op1_type, opline->op1.var);
3893
0
    FREE_OP(opline->op2_type, opline->op2.var);
3894
0
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3895
0
    HANDLE_EXCEPTION();
3896
0
  }
3897
3898
#if 0 || 0
3899
  if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3900
    zend_frameless_observed_call(execute_data);
3901
  } else
3902
#endif
3903
0
  {
3904
0
    zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline);
3905
0
    function(result, arg1, arg2, arg3);
3906
0
  }
3907
3908
0
  FREE_OP(opline->op1_type, opline->op1.var);
3909
  /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3910
0
  if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3911
0
    ZVAL_UNDEF(EX_VAR(opline->op1.var));
3912
0
  }
3913
0
  FREE_OP(opline->op2_type, opline->op2.var);
3914
0
  if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
3915
0
    ZVAL_UNDEF(EX_VAR(opline->op2.var));
3916
0
  }
3917
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3918
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
3919
0
}
3920
3921
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3922
0
{
3923
0
  USE_OPLINE
3924
0
  SAVE_OPLINE();
3925
3926
0
  zval *result = EX_VAR(opline->result.var);
3927
0
  ZVAL_NULL(result);
3928
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3929
0
  zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3930
0
  zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1);
3931
0
  if (EG(exception)) {
3932
0
    FREE_OP(opline->op1_type, opline->op1.var);
3933
0
    FREE_OP(opline->op2_type, opline->op2.var);
3934
0
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3935
0
    HANDLE_EXCEPTION();
3936
0
  }
3937
3938
0
#if 0 || 1
3939
0
  if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3940
0
    zend_frameless_observed_call(execute_data);
3941
0
  } else
3942
0
#endif
3943
0
  {
3944
0
    zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline);
3945
0
    function(result, arg1, arg2, arg3);
3946
0
  }
3947
3948
0
  FREE_OP(opline->op1_type, opline->op1.var);
3949
  /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3950
0
  if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3951
0
    ZVAL_UNDEF(EX_VAR(opline->op1.var));
3952
0
  }
3953
0
  FREE_OP(opline->op2_type, opline->op2.var);
3954
0
  if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
3955
0
    ZVAL_UNDEF(EX_VAR(opline->op2.var));
3956
0
  }
3957
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3958
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
3959
0
}
3960
3961
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3962
16.4k
{
3963
16.4k
  USE_OPLINE
3964
3965
16.4k
  OPLINE = OP_JMP_ADDR(opline, opline->op1);
3966
16.4k
  ZEND_VM_CONTINUE();
3967
16.4k
}
3968
3969
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
3970
0
{
3971
0
  zend_atomic_bool_store_ex(&EG(vm_interrupt), false);
3972
0
  SAVE_OPLINE();
3973
0
  if (zend_atomic_bool_load_ex(&EG(timed_out))) {
3974
0
    zend_timeout();
3975
0
  } else if (zend_interrupt_function) {
3976
0
    zend_interrupt_function(execute_data);
3977
0
    if (EG(exception)) {
3978
      /* We have to UNDEF result, because ZEND_HANDLE_EXCEPTION is going to free it */
3979
0
      const zend_op *throw_op = EG(opline_before_exception);
3980
3981
0
      if (throw_op
3982
0
       && throw_op->result_type & (IS_TMP_VAR|IS_VAR)
3983
0
       && throw_op->opcode != ZEND_ADD_ARRAY_ELEMENT
3984
0
       && throw_op->opcode != ZEND_ADD_ARRAY_UNPACK
3985
0
       && throw_op->opcode != ZEND_ROPE_INIT
3986
0
       && throw_op->opcode != ZEND_ROPE_ADD) {
3987
0
        ZVAL_UNDEF(ZEND_CALL_VAR(EG(current_execute_data), throw_op->result.var));
3988
3989
0
      }
3990
0
    }
3991
0
    ZEND_VM_ENTER();
3992
0
  }
3993
0
  ZEND_VM_CONTINUE();
3994
0
}
3995
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3996
2.87k
{
3997
2.87k
  USE_OPLINE
3998
2.87k
  zend_function *fbc;
3999
2.87k
  zval *function_name, *func;
4000
2.87k
  zend_execute_data *call;
4001
4002
2.87k
  fbc = CACHED_PTR(opline->result.num);
4003
2.87k
  if (UNEXPECTED(fbc == NULL)) {
4004
2.86k
    function_name = (zval*)RT_CONSTANT(opline, opline->op2);
4005
2.86k
    func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(function_name+1));
4006
2.86k
    if (UNEXPECTED(func == NULL)) {
4007
2.77k
      ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4008
2.77k
    }
4009
92
    fbc = Z_FUNC_P(func);
4010
92
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
4011
87
      init_func_run_time_cache(&fbc->op_array);
4012
87
    }
4013
92
    CACHE_PTR(opline->result.num, fbc);
4014
92
  }
4015
102
  call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
4016
102
    fbc, opline->extended_value, NULL);
4017
102
  call->prev_execute_data = EX(call);
4018
102
  EX(call) = call;
4019
4020
102
  ZEND_VM_NEXT_OPCODE();
4021
102
}
4022
4023
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4024
53
{
4025
53
  USE_OPLINE
4026
53
  zval *function_name;
4027
53
  zend_execute_data *call;
4028
4029
53
  SAVE_OPLINE();
4030
53
  function_name = RT_CONSTANT(opline, opline->op2);
4031
4032
53
try_function_name:
4033
53
  if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4034
0
    call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4035
53
  } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4036
0
    call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4037
53
  } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4038
48
    call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4039
48
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4040
0
    function_name = Z_REFVAL_P(function_name);
4041
0
    goto try_function_name;
4042
5
  } else {
4043
5
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4044
0
      function_name = ZVAL_UNDEFINED_OP2();
4045
0
      if (UNEXPECTED(EG(exception) != NULL)) {
4046
0
        HANDLE_EXCEPTION();
4047
0
      }
4048
0
    }
4049
5
    zend_throw_error(NULL, "Value of type %s is not callable",
4050
5
      zend_zval_type_name(function_name));
4051
5
    call = NULL;
4052
5
  }
4053
4054
53
  if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
4055
4056
0
    if (UNEXPECTED(EG(exception))) {
4057
0
      if (call) {
4058
0
         if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4059
0
          zend_string_release_ex(call->func->common.function_name, 0);
4060
0
          zend_free_trampoline(call->func);
4061
0
        }
4062
0
        zend_vm_stack_free_call_frame(call);
4063
0
      }
4064
0
      HANDLE_EXCEPTION();
4065
0
    }
4066
53
  } else if (!call) {
4067
23
    HANDLE_EXCEPTION();
4068
23
  }
4069
4070
30
  call->prev_execute_data = EX(call);
4071
30
  EX(call) = call;
4072
4073
30
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4074
30
}
4075
4076
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4077
3.06k
{
4078
3.06k
  USE_OPLINE
4079
3.06k
  zval *func_name;
4080
3.06k
  zval *func;
4081
3.06k
  zend_function *fbc;
4082
3.06k
  zend_execute_data *call;
4083
4084
3.06k
  fbc = CACHED_PTR(opline->result.num);
4085
3.06k
  if (UNEXPECTED(fbc == NULL)) {
4086
1.33k
    func_name = (zval *)RT_CONSTANT(opline, opline->op2);
4087
1.33k
    func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name + 1));
4088
1.33k
    if (func == NULL) {
4089
1.32k
      func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name + 2));
4090
1.32k
      if (UNEXPECTED(func == NULL)) {
4091
66
        ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4092
66
      }
4093
1.32k
    }
4094
1.27k
    fbc = Z_FUNC_P(func);
4095
1.27k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
4096
13
      init_func_run_time_cache(&fbc->op_array);
4097
13
    }
4098
1.27k
    CACHE_PTR(opline->result.num, fbc);
4099
1.27k
  }
4100
4101
3.00k
  call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
4102
3.00k
    fbc, opline->extended_value, NULL);
4103
3.00k
  call->prev_execute_data = EX(call);
4104
3.00k
  EX(call) = call;
4105
4106
3.00k
  ZEND_VM_NEXT_OPCODE();
4107
3.00k
}
4108
4109
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4110
299k
{
4111
299k
  USE_OPLINE
4112
299k
  zval *fname;
4113
299k
  zval *func;
4114
299k
  zend_function *fbc;
4115
299k
  zend_execute_data *call;
4116
4117
299k
  fbc = CACHED_PTR(opline->result.num);
4118
299k
  if (UNEXPECTED(fbc == NULL)) {
4119
183k
    fname = (zval*)RT_CONSTANT(opline, opline->op2);
4120
183k
    func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(fname));
4121
183k
    ZEND_ASSERT(func != NULL && "Function existence must be checked at compile time");
4122
183k
    fbc = Z_FUNC_P(func);
4123
183k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
4124
13.5k
      init_func_run_time_cache(&fbc->op_array);
4125
13.5k
    }
4126
183k
    CACHE_PTR(opline->result.num, fbc);
4127
183k
  }
4128
4129
299k
  call = _zend_vm_stack_push_call_frame_ex(
4130
299k
    opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
4131
299k
    fbc, opline->extended_value, NULL);
4132
299k
  call->prev_execute_data = EX(call);
4133
299k
  EX(call) = call;
4134
4135
299k
  ZEND_VM_NEXT_OPCODE();
4136
299k
}
4137
4138
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4139
163k
{
4140
163k
  USE_OPLINE
4141
163k
  zend_function *fbc;
4142
163k
  zend_execute_data *call;
4143
163k
  fbc = CACHED_PTR(opline->result.num);
4144
163k
  if (UNEXPECTED(fbc == NULL)) {
4145
36.8k
    fbc = Z_PTR(EG(function_table)->arData[Z_EXTRA_P(RT_CONSTANT(opline, opline->op2))].val);
4146
36.8k
    CACHE_PTR(opline->result.num, fbc);
4147
36.8k
  }
4148
163k
  call = _zend_vm_stack_push_call_frame_ex(
4149
163k
    opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
4150
163k
    fbc, opline->extended_value, NULL);
4151
163k
  call->prev_execute_data = EX(call);
4152
163k
  EX(call) = call;
4153
163k
  ZEND_VM_NEXT_OPCODE();
4154
163k
}
4155
4156
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4157
1.99k
{
4158
1.99k
  USE_OPLINE
4159
1.99k
  uint32_t arg_num;
4160
1.99k
  zval *param;
4161
4162
2.71k
  ZEND_VM_REPEATABLE_OPCODE
4163
4164
2.71k
  arg_num = opline->op1.num;
4165
2.71k
  param = EX_VAR(opline->result.var);
4166
2.71k
  if (arg_num > EX_NUM_ARGS()) {
4167
1.38k
    zval *default_value = RT_CONSTANT(opline, opline->op2);
4168
4169
1.38k
    if (Z_OPT_TYPE_P(default_value) == IS_CONSTANT_AST) {
4170
526
      zval *cache_val = (zval*)CACHE_ADDR(Z_CACHE_SLOT_P(default_value));
4171
4172
      /* we keep in cache only not refcounted values */
4173
526
      if (Z_TYPE_P(cache_val) != IS_UNDEF) {
4174
5
        ZVAL_COPY_VALUE(param, cache_val);
4175
521
      } else {
4176
521
        SAVE_OPLINE();
4177
521
        ZVAL_COPY(param, default_value);
4178
521
        zend_ast_evaluate_ctx ctx = {0};
4179
521
        if (UNEXPECTED(zval_update_constant_with_ctx(param, EX(func)->op_array.scope, &ctx) != SUCCESS)) {
4180
135
          zval_ptr_dtor_nogc(param);
4181
135
          ZVAL_UNDEF(param);
4182
135
          HANDLE_EXCEPTION();
4183
135
        }
4184
386
        if (!Z_REFCOUNTED_P(param) && !ctx.had_side_effects) {
4185
229
          ZVAL_COPY_VALUE(cache_val, param);
4186
229
        }
4187
386
      }
4188
391
      goto recv_init_check_type;
4189
854
    } else {
4190
854
      ZVAL_COPY(param, default_value);
4191
854
    }
4192
1.38k
  } else {
4193
1.72k
recv_init_check_type:
4194
1.72k
    if ((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0) {
4195
1.44k
      SAVE_OPLINE();
4196
1.44k
      if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), arg_num, param))) {
4197
50
        HANDLE_EXCEPTION();
4198
50
      }
4199
1.44k
    }
4200
1.72k
  }
4201
4202
2.71k
  ZEND_VM_REPEAT_OPCODE(ZEND_RECV_INIT);
4203
0
  ZEND_VM_NEXT_OPCODE();
4204
0
}
4205
4206
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4207
2.22k
{
4208
2.22k
  USE_OPLINE
4209
2.22k
  zval *function_name;
4210
2.22k
  zend_execute_data *call;
4211
4212
2.22k
  SAVE_OPLINE();
4213
2.22k
  function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
4214
4215
2.22k
try_function_name:
4216
2.22k
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4217
363
    call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4218
1.86k
  } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4219
1.78k
    call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4220
1.78k
  } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4221
54
    call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4222
54
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4223
0
    function_name = Z_REFVAL_P(function_name);
4224
0
    goto try_function_name;
4225
19
  } else {
4226
19
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4227
0
      function_name = ZVAL_UNDEFINED_OP2();
4228
0
      if (UNEXPECTED(EG(exception) != NULL)) {
4229
0
        HANDLE_EXCEPTION();
4230
0
      }
4231
0
    }
4232
19
    zend_throw_error(NULL, "Value of type %s is not callable",
4233
19
      zend_zval_type_name(function_name));
4234
19
    call = NULL;
4235
19
  }
4236
4237
2.22k
  if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) {
4238
2.22k
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
4239
2.22k
    if (UNEXPECTED(EG(exception))) {
4240
80
      if (call) {
4241
5
         if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4242
0
          zend_string_release_ex(call->func->common.function_name, 0);
4243
0
          zend_free_trampoline(call->func);
4244
0
        }
4245
5
        zend_vm_stack_free_call_frame(call);
4246
5
      }
4247
80
      HANDLE_EXCEPTION();
4248
80
    }
4249
2.22k
  } else if (!call) {
4250
0
    HANDLE_EXCEPTION();
4251
0
  }
4252
4253
2.14k
  call->prev_execute_data = EX(call);
4254
2.14k
  EX(call) = call;
4255
4256
2.14k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4257
2.14k
}
4258
4259
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4260
14.2k
{
4261
14.2k
  USE_OPLINE
4262
14.2k
  uint32_t arg_num = opline->op1.num;
4263
14.2k
  zval *param;
4264
4265
14.2k
  if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
4266
89
    ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4267
89
  }
4268
4269
14.1k
  param = EX_VAR(opline->result.var);
4270
4271
14.1k
  if (UNEXPECTED(!(opline->op2.num & (1u << Z_TYPE_P(param))))) {
4272
3.46k
    ZEND_VM_TAIL_CALL(zend_verify_recv_arg_type_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX param));
4273
3.46k
  }
4274
4275
10.7k
  ZEND_VM_NEXT_OPCODE();
4276
10.7k
}
4277
4278
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4279
592
{
4280
592
  USE_OPLINE
4281
592
  uint32_t arg_num = opline->op1.num;
4282
592
  uint32_t arg_count = EX_NUM_ARGS();
4283
592
  zval *params;
4284
4285
592
  SAVE_OPLINE();
4286
4287
592
  params = EX_VAR(opline->result.var);
4288
4289
592
  if (arg_num <= arg_count) {
4290
477
    ZEND_ASSERT(EX(func)->common.fn_flags & ZEND_ACC_VARIADIC);
4291
477
    ZEND_ASSERT(EX(func)->common.num_args == arg_num - 1);
4292
477
    zend_arg_info *arg_info = &EX(func)->common.arg_info[arg_num - 1];
4293
4294
477
    array_init_size(params, arg_count - arg_num + 1);
4295
477
    zend_hash_real_init_packed(Z_ARRVAL_P(params));
4296
477
    ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
4297
477
      zval *param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
4298
477
      if (ZEND_TYPE_IS_SET(arg_info->type)) {
4299
73
        ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_FREE_EXTRA_ARGS);
4300
148
        do {
4301
148
          if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param))) {
4302
26
            ZEND_HASH_FILL_FINISH();
4303
26
            HANDLE_EXCEPTION();
4304
26
          }
4305
4306
122
          if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4307
122
          ZEND_HASH_FILL_ADD(param);
4308
122
          param++;
4309
122
        } while (++arg_num <= arg_count);
4310
404
      } else {
4311
170k
        do {
4312
170k
          if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4313
170k
          ZEND_HASH_FILL_ADD(param);
4314
170k
          param++;
4315
170k
        } while (++arg_num <= arg_count);
4316
404
      }
4317
477
    } ZEND_HASH_FILL_END();
4318
477
  } else {
4319
115
    ZVAL_EMPTY_ARRAY(params);
4320
115
  }
4321
4322
566
  if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
4323
128
    zend_string *name;
4324
128
    zval *param;
4325
128
    zend_arg_info *arg_info = &EX(func)->common.arg_info[EX(func)->common.num_args];
4326
128
    if (ZEND_TYPE_IS_SET(arg_info->type)) {
4327
21
      SEPARATE_ARRAY(params);
4328
124
      ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4329
124
        if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param))) {
4330
3
          HANDLE_EXCEPTION();
4331
3
        }
4332
38
        Z_TRY_ADDREF_P(param);
4333
38
        zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4334
38
      } ZEND_HASH_FOREACH_END();
4335
107
    } else if (zend_hash_num_elements(Z_ARRVAL_P(params)) == 0) {
4336
23
      GC_ADDREF(EX(extra_named_params));
4337
23
      ZVAL_ARR(params, EX(extra_named_params));
4338
84
    } else {
4339
84
      SEPARATE_ARRAY(params);
4340
374
      ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4341
374
        Z_TRY_ADDREF_P(param);
4342
374
        zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4343
374
      } ZEND_HASH_FOREACH_END();
4344
84
    }
4345
128
  }
4346
4347
563
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4348
563
}
4349
4350
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4351
0
{
4352
0
  USE_OPLINE
4353
0
  SAVE_OPLINE();
4354
4355
0
  zval *result = EX_VAR(opline->result.var);
4356
0
  ZVAL_NULL(result);
4357
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
4358
0
  if (EG(exception)) {
4359
0
    FREE_OP(opline->op1_type, opline->op1.var);
4360
0
    HANDLE_EXCEPTION();
4361
0
  }
4362
4363
#if 0 || 0
4364
  if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
4365
    zend_frameless_observed_call(execute_data);
4366
  } else
4367
#endif
4368
0
  {
4369
0
    zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline);
4370
0
    function(result, arg1);
4371
0
  }
4372
0
  FREE_OP(opline->op1_type, opline->op1.var);
4373
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4374
0
}
4375
4376
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4377
0
{
4378
0
  USE_OPLINE
4379
0
  SAVE_OPLINE();
4380
4381
0
  zval *result = EX_VAR(opline->result.var);
4382
0
  ZVAL_NULL(result);
4383
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
4384
0
  if (EG(exception)) {
4385
0
    FREE_OP(opline->op1_type, opline->op1.var);
4386
0
    HANDLE_EXCEPTION();
4387
0
  }
4388
4389
0
#if 0 || 1
4390
0
  if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
4391
0
    zend_frameless_observed_call(execute_data);
4392
0
  } else
4393
0
#endif
4394
0
  {
4395
0
    zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline);
4396
0
    function(result, arg1);
4397
0
  }
4398
0
  FREE_OP(opline->op1_type, opline->op1.var);
4399
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4400
0
}
4401
4402
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4403
5.15k
{
4404
5.15k
  USE_OPLINE
4405
5.15k
  zval *function_name;
4406
5.15k
  zend_execute_data *call;
4407
4408
5.15k
  SAVE_OPLINE();
4409
5.15k
  function_name = EX_VAR(opline->op2.var);
4410
4411
5.49k
try_function_name:
4412
5.49k
  if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4413
974
    call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4414
4.52k
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4415
3.60k
    call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4416
3.60k
  } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4417
167
    call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4418
751
  } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4419
336
    function_name = Z_REFVAL_P(function_name);
4420
336
    goto try_function_name;
4421
415
  } else {
4422
415
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4423
399
      function_name = ZVAL_UNDEFINED_OP2();
4424
399
      if (UNEXPECTED(EG(exception) != NULL)) {
4425
14
        HANDLE_EXCEPTION();
4426
14
      }
4427
399
    }
4428
401
    zend_throw_error(NULL, "Value of type %s is not callable",
4429
401
      zend_zval_type_name(function_name));
4430
401
    call = NULL;
4431
401
  }
4432
4433
5.14k
  if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
4434
4435
0
    if (UNEXPECTED(EG(exception))) {
4436
0
      if (call) {
4437
0
         if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4438
0
          zend_string_release_ex(call->func->common.function_name, 0);
4439
0
          zend_free_trampoline(call->func);
4440
0
        }
4441
0
        zend_vm_stack_free_call_frame(call);
4442
0
      }
4443
0
      HANDLE_EXCEPTION();
4444
0
    }
4445
5.14k
  } else if (!call) {
4446
580
    HANDLE_EXCEPTION();
4447
580
  }
4448
4449
4.56k
  call->prev_execute_data = EX(call);
4450
4.56k
  EX(call) = call;
4451
4452
4.56k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4453
4.56k
}
4454
4455
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4456
282
{
4457
282
  USE_OPLINE
4458
282
  zval *op1;
4459
4460
282
  op1 = RT_CONSTANT(opline, opline->op1);
4461
282
  if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
4462
0
    ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
4463
0
    ZEND_VM_NEXT_OPCODE();
4464
0
  }
4465
4466
282
  ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1));
4467
282
}
4468
4469
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4470
164
{
4471
164
  USE_OPLINE
4472
164
  zval *val;
4473
4474
164
  val = RT_CONSTANT(opline, opline->op1);
4475
164
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4476
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4477
164
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4478
    /* The result and op1 can be the same cv zval */
4479
161
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
4480
161
    ZVAL_TRUE(EX_VAR(opline->result.var));
4481
161
    if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
4482
0
      SAVE_OPLINE();
4483
0
      ZVAL_UNDEFINED_OP1();
4484
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4485
0
    }
4486
161
  } else {
4487
3
    SAVE_OPLINE();
4488
3
    ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
4489
4490
3
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4491
3
  }
4492
161
  ZEND_VM_NEXT_OPCODE();
4493
161
}
4494
4495
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4496
373k
{
4497
373k
  USE_OPLINE
4498
373k
  zval *z;
4499
4500
373k
  SAVE_OPLINE();
4501
373k
  z = RT_CONSTANT(opline, opline->op1);
4502
4503
373k
  if (Z_TYPE_P(z) == IS_STRING) {
4504
373k
    zend_string *str = Z_STR_P(z);
4505
4506
373k
    if (ZSTR_LEN(str) != 0) {
4507
373k
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4508
373k
    }
4509
373k
  } else {
4510
767
    zend_string *str = zval_get_string_func(z);
4511
4512
767
    if (ZSTR_LEN(str) != 0) {
4513
574
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4514
574
    } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
4515
0
      ZVAL_UNDEFINED_OP1();
4516
0
    }
4517
767
    zend_string_release_ex(str, 0);
4518
767
  }
4519
4520
373k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4521
373k
}
4522
4523
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4524
22
{
4525
22
  USE_OPLINE
4526
22
  zval *val;
4527
22
  uint8_t op1_type;
4528
4529
22
  val = RT_CONSTANT(opline, opline->op1);
4530
4531
22
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4532
2
    ZEND_VM_NEXT_OPCODE();
4533
20
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4534
2
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4535
0
      SAVE_OPLINE();
4536
0
      ZVAL_UNDEFINED_OP1();
4537
0
      if (UNEXPECTED(EG(exception))) {
4538
0
        HANDLE_EXCEPTION();
4539
0
      }
4540
0
    }
4541
2
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4542
2
  }
4543
4544
22
  SAVE_OPLINE();
4545
18
  op1_type = IS_CONST;
4546
18
  if (i_zend_is_true(val)) {
4547
18
    opline++;
4548
18
  } else {
4549
0
    opline = OP_JMP_ADDR(opline, opline->op2);
4550
0
  }
4551
18
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4552
0
    zval_ptr_dtor_nogc(val);
4553
0
  }
4554
18
  ZEND_VM_JMP(opline);
4555
18
}
4556
4557
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4558
217
{
4559
217
  USE_OPLINE
4560
217
  zval *val;
4561
217
  uint8_t op1_type;
4562
4563
217
  val = RT_CONSTANT(opline, opline->op1);
4564
4565
217
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4566
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4567
217
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4568
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4569
0
      SAVE_OPLINE();
4570
0
      ZVAL_UNDEFINED_OP1();
4571
0
      if (UNEXPECTED(EG(exception))) {
4572
0
        HANDLE_EXCEPTION();
4573
0
      }
4574
0
    }
4575
0
    ZEND_VM_NEXT_OPCODE();
4576
0
  }
4577
4578
217
  SAVE_OPLINE();
4579
217
  op1_type = IS_CONST;
4580
217
  if (i_zend_is_true(val)) {
4581
217
    opline = OP_JMP_ADDR(opline, opline->op2);
4582
217
  } else {
4583
0
    opline++;
4584
0
  }
4585
217
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4586
0
    zval_ptr_dtor_nogc(val);
4587
0
  }
4588
217
  ZEND_VM_JMP(opline);
4589
217
}
4590
4591
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4592
0
{
4593
0
  USE_OPLINE
4594
0
  zval *val;
4595
0
  bool ret;
4596
4597
0
  val = RT_CONSTANT(opline, opline->op1);
4598
4599
0
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4600
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
4601
0
    ZEND_VM_NEXT_OPCODE();
4602
0
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4603
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4604
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4605
0
      SAVE_OPLINE();
4606
0
      ZVAL_UNDEFINED_OP1();
4607
0
      if (UNEXPECTED(EG(exception))) {
4608
0
        HANDLE_EXCEPTION();
4609
0
      }
4610
0
    }
4611
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4612
0
  }
4613
4614
0
  SAVE_OPLINE();
4615
0
  ret = i_zend_is_true(val);
4616
4617
0
  if (ret) {
4618
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
4619
0
    opline++;
4620
0
  } else {
4621
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4622
0
    opline = OP_JMP_ADDR(opline, opline->op2);
4623
0
  }
4624
0
  ZEND_VM_JMP(opline);
4625
0
}
4626
4627
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4628
5
{
4629
5
  USE_OPLINE
4630
5
  zval *val;
4631
5
  bool ret;
4632
4633
5
  val = RT_CONSTANT(opline, opline->op1);
4634
4635
5
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4636
5
    ZVAL_TRUE(EX_VAR(opline->result.var));
4637
5
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4638
5
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4639
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4640
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4641
0
      SAVE_OPLINE();
4642
0
      ZVAL_UNDEFINED_OP1();
4643
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4644
0
    } else {
4645
0
      ZEND_VM_NEXT_OPCODE();
4646
0
    }
4647
0
  }
4648
4649
5
  SAVE_OPLINE();
4650
0
  ret = i_zend_is_true(val);
4651
4652
0
  if (ret) {
4653
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
4654
0
    opline = OP_JMP_ADDR(opline, opline->op2);
4655
0
  } else {
4656
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4657
0
    opline++;
4658
0
  }
4659
0
  ZEND_VM_JMP(opline);
4660
0
}
4661
4662
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4663
90.7k
{
4664
90.7k
  USE_OPLINE
4665
90.7k
  zval *retval_ptr;
4666
90.7k
  zval *return_value;
4667
4668
90.7k
  retval_ptr = RT_CONSTANT(opline, opline->op1);
4669
90.7k
  return_value = EX(return_value);
4670
4671
90.7k
  if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4672
0
    SAVE_OPLINE();
4673
0
    retval_ptr = ZVAL_UNDEFINED_OP1();
4674
0
    if (return_value) {
4675
0
      ZVAL_NULL(return_value);
4676
0
    }
4677
90.7k
  } else if (!return_value) {
4678
70.7k
    if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
4679
0
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4680
0
        SAVE_OPLINE();
4681
0
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
4682
0
      }
4683
0
    }
4684
70.7k
  } else {
4685
19.9k
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4686
19.9k
      ZVAL_COPY_VALUE(return_value, retval_ptr);
4687
19.9k
      if (IS_CONST == IS_CONST) {
4688
19.9k
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4689
0
          Z_ADDREF_P(return_value);
4690
0
        }
4691
19.9k
      }
4692
19.9k
    } else if (IS_CONST == IS_CV) {
4693
0
      do {
4694
0
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4695
0
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4696
0
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4697
0
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4698
0
              ZVAL_COPY_VALUE(return_value, retval_ptr);
4699
0
              if (GC_MAY_LEAK(ref)) {
4700
0
                SAVE_OPLINE();
4701
0
                gc_possible_root(ref);
4702
0
              }
4703
0
              ZVAL_NULL(retval_ptr);
4704
0
              break;
4705
0
            } else {
4706
0
              Z_ADDREF_P(retval_ptr);
4707
0
            }
4708
0
          } else {
4709
0
            retval_ptr = Z_REFVAL_P(retval_ptr);
4710
0
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4711
0
              Z_ADDREF_P(retval_ptr);
4712
0
            }
4713
0
          }
4714
0
        }
4715
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4716
0
      } while (0);
4717
0
    } else /* if (IS_CONST == IS_VAR) */ {
4718
0
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4719
0
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4720
4721
0
        retval_ptr = Z_REFVAL_P(retval_ptr);
4722
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4723
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4724
0
          efree_size(ref, sizeof(zend_reference));
4725
0
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4726
0
          Z_ADDREF_P(retval_ptr);
4727
0
        }
4728
0
      } else {
4729
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4730
0
      }
4731
0
    }
4732
19.9k
  }
4733
4734
4735
4736
90.7k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4737
90.7k
}
4738
4739
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4740
0
{
4741
0
  USE_OPLINE
4742
0
  zval *retval_ptr;
4743
0
  zval *return_value;
4744
0
  zval observer_retval;
4745
4746
0
  retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
4747
0
  return_value = EX(return_value);
4748
0
  if (!return_value) { return_value = &observer_retval; };
4749
0
  if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4750
0
    SAVE_OPLINE();
4751
0
    retval_ptr = ZVAL_UNDEFINED_OP1();
4752
0
    if (return_value) {
4753
0
      ZVAL_NULL(return_value);
4754
0
    }
4755
0
  } else if (!return_value) {
4756
0
    if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
4757
0
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4758
0
        SAVE_OPLINE();
4759
0
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
4760
0
      }
4761
0
    }
4762
0
  } else {
4763
0
    if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
4764
0
      ZVAL_COPY_VALUE(return_value, retval_ptr);
4765
0
      if (opline->op1_type == IS_CONST) {
4766
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4767
0
          Z_ADDREF_P(return_value);
4768
0
        }
4769
0
      }
4770
0
    } else if (opline->op1_type == IS_CV) {
4771
0
      do {
4772
0
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4773
0
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4774
0
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4775
0
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4776
0
              ZVAL_COPY_VALUE(return_value, retval_ptr);
4777
0
              if (GC_MAY_LEAK(ref)) {
4778
0
                SAVE_OPLINE();
4779
0
                gc_possible_root(ref);
4780
0
              }
4781
0
              ZVAL_NULL(retval_ptr);
4782
0
              break;
4783
0
            } else {
4784
0
              Z_ADDREF_P(retval_ptr);
4785
0
            }
4786
0
          } else {
4787
0
            retval_ptr = Z_REFVAL_P(retval_ptr);
4788
0
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4789
0
              Z_ADDREF_P(retval_ptr);
4790
0
            }
4791
0
          }
4792
0
        }
4793
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4794
0
      } while (0);
4795
0
    } else /* if (opline->op1_type == IS_VAR) */ {
4796
0
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4797
0
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4798
4799
0
        retval_ptr = Z_REFVAL_P(retval_ptr);
4800
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4801
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4802
0
          efree_size(ref, sizeof(zend_reference));
4803
0
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4804
0
          Z_ADDREF_P(retval_ptr);
4805
0
        }
4806
0
      } else {
4807
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4808
0
      }
4809
0
    }
4810
0
  }
4811
0
  SAVE_OPLINE();
4812
0
  zend_observer_fcall_end(execute_data, return_value);
4813
0
  if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4814
0
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4815
0
}
4816
4817
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4818
49
{
4819
49
  USE_OPLINE
4820
49
  zval *retval_ptr;
4821
49
  zval *return_value;
4822
4823
49
  SAVE_OPLINE();
4824
4825
49
  return_value = EX(return_value);
4826
4827
49
  do {
4828
49
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR)) ||
4829
49
        (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4830
      /* Not supposed to happen, but we'll allow it */
4831
49
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
4832
4833
49
      retval_ptr = RT_CONSTANT(opline, opline->op1);
4834
49
      if (!return_value) {
4835
4836
49
      } else {
4837
49
        if (IS_CONST == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4838
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
4839
0
          break;
4840
0
        }
4841
4842
49
        ZVAL_NEW_REF(return_value, retval_ptr);
4843
49
        if (IS_CONST == IS_CONST) {
4844
49
          Z_TRY_ADDREF_P(retval_ptr);
4845
49
        }
4846
49
      }
4847
49
      break;
4848
49
    }
4849
4850
0
    retval_ptr = zend_get_bad_ptr();
4851
4852
0
    if (IS_CONST == IS_VAR) {
4853
0
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4854
0
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4855
0
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
4856
0
        if (return_value) {
4857
0
          ZVAL_NEW_REF(return_value, retval_ptr);
4858
0
        } else {
4859
4860
0
        }
4861
0
        break;
4862
0
      }
4863
0
    }
4864
4865
0
    if (return_value) {
4866
0
      if (Z_ISREF_P(retval_ptr)) {
4867
0
        Z_ADDREF_P(retval_ptr);
4868
0
      } else {
4869
0
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
4870
0
      }
4871
0
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4872
0
    }
4873
4874
0
  } while (0);
4875
4876
4877
49
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4878
49
}
4879
4880
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4881
0
{
4882
0
  USE_OPLINE
4883
0
  zval *retval_ptr;
4884
0
  zval *return_value;
4885
0
  zval observer_retval;
4886
4887
0
  SAVE_OPLINE();
4888
4889
0
  return_value = EX(return_value);
4890
0
  if (!return_value) { return_value = &observer_retval; };
4891
0
  do {
4892
0
    if ((opline->op1_type & (IS_CONST|IS_TMP_VAR)) ||
4893
0
        (opline->op1_type == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4894
      /* Not supposed to happen, but we'll allow it */
4895
0
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
4896
4897
0
      retval_ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
4898
0
      if (!return_value) {
4899
0
        FREE_OP(opline->op1_type, opline->op1.var);
4900
0
      } else {
4901
0
        if (opline->op1_type == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4902
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
4903
0
          break;
4904
0
        }
4905
4906
0
        ZVAL_NEW_REF(return_value, retval_ptr);
4907
0
        if (opline->op1_type == IS_CONST) {
4908
0
          Z_TRY_ADDREF_P(retval_ptr);
4909
0
        }
4910
0
      }
4911
0
      break;
4912
0
    }
4913
4914
0
    retval_ptr = get_zval_ptr_ptr(opline->op1_type, opline->op1, BP_VAR_W);
4915
4916
0
    if (opline->op1_type == IS_VAR) {
4917
0
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4918
0
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4919
0
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
4920
0
        if (return_value) {
4921
0
          ZVAL_NEW_REF(return_value, retval_ptr);
4922
0
        } else {
4923
0
          FREE_OP(opline->op1_type, opline->op1.var);
4924
0
        }
4925
0
        break;
4926
0
      }
4927
0
    }
4928
4929
0
    if (return_value) {
4930
0
      if (Z_ISREF_P(retval_ptr)) {
4931
0
        Z_ADDREF_P(retval_ptr);
4932
0
      } else {
4933
0
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
4934
0
      }
4935
0
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4936
0
    }
4937
4938
0
    FREE_OP(opline->op1_type, opline->op1.var);
4939
0
  } while (0);
4940
4941
0
  zend_observer_fcall_end(execute_data, return_value);
4942
0
  if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4943
0
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4944
0
}
4945
4946
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4947
1.39k
{
4948
1.39k
  USE_OPLINE
4949
1.39k
  zval *retval;
4950
4951
1.39k
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4952
4953
1.39k
  SAVE_OPLINE();
4954
1.39k
  retval = RT_CONSTANT(opline, opline->op1);
4955
4956
  /* Copy return value into generator->retval */
4957
1.39k
  if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4958
1.39k
    ZVAL_COPY_VALUE(&generator->retval, retval);
4959
1.39k
    if (IS_CONST == IS_CONST) {
4960
1.39k
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
4961
0
        Z_ADDREF(generator->retval);
4962
0
      }
4963
1.39k
    }
4964
1.39k
  } else if (IS_CONST == IS_CV) {
4965
0
    ZVAL_COPY_DEREF(&generator->retval, retval);
4966
0
  } else /* if (IS_CONST == IS_VAR) */ {
4967
0
    if (UNEXPECTED(Z_ISREF_P(retval))) {
4968
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
4969
4970
0
      retval = Z_REFVAL_P(retval);
4971
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
4972
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4973
0
        efree_size(ref, sizeof(zend_reference));
4974
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
4975
0
        Z_ADDREF_P(retval);
4976
0
      }
4977
0
    } else {
4978
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
4979
0
    }
4980
0
  }
4981
4982
1.39k
  EG(current_execute_data) = EX(prev_execute_data);
4983
4984
  /* Close the generator to free up resources */
4985
1.39k
  zend_generator_close(generator, 1);
4986
4987
  /* Pass execution back to handling code */
4988
1.39k
  ZEND_VM_RETURN();
4989
1.39k
}
4990
4991
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4992
0
{
4993
0
  USE_OPLINE
4994
0
  zval *retval;
4995
4996
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4997
4998
0
  SAVE_OPLINE();
4999
0
  retval = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
5000
5001
  /* Copy return value into generator->retval */
5002
0
  if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
5003
0
    ZVAL_COPY_VALUE(&generator->retval, retval);
5004
0
    if (opline->op1_type == IS_CONST) {
5005
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
5006
0
        Z_ADDREF(generator->retval);
5007
0
      }
5008
0
    }
5009
0
  } else if (opline->op1_type == IS_CV) {
5010
0
    ZVAL_COPY_DEREF(&generator->retval, retval);
5011
0
  } else /* if (opline->op1_type == IS_VAR) */ {
5012
0
    if (UNEXPECTED(Z_ISREF_P(retval))) {
5013
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
5014
5015
0
      retval = Z_REFVAL_P(retval);
5016
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
5017
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5018
0
        efree_size(ref, sizeof(zend_reference));
5019
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
5020
0
        Z_ADDREF_P(retval);
5021
0
      }
5022
0
    } else {
5023
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
5024
0
    }
5025
0
  }
5026
5027
0
  zend_observer_fcall_end(generator->execute_data, &generator->retval);
5028
5029
0
  EG(current_execute_data) = EX(prev_execute_data);
5030
5031
  /* Close the generator to free up resources */
5032
0
  zend_generator_close(generator, 1);
5033
5034
  /* Pass execution back to handling code */
5035
0
  ZEND_VM_RETURN();
5036
0
}
5037
5038
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5039
5
{
5040
5
  USE_OPLINE
5041
5
  zval *value;
5042
5043
5
  SAVE_OPLINE();
5044
5
  value = RT_CONSTANT(opline, opline->op1);
5045
5046
5
  do {
5047
5
    if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
5048
5
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
5049
0
        value = Z_REFVAL_P(value);
5050
0
        if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
5051
0
          break;
5052
0
        }
5053
0
      }
5054
5
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5055
0
        ZVAL_UNDEFINED_OP1();
5056
0
        if (UNEXPECTED(EG(exception) != NULL)) {
5057
0
          HANDLE_EXCEPTION();
5058
0
        }
5059
0
      }
5060
5
      zend_throw_error(NULL, "Can only throw objects");
5061
5062
5
      HANDLE_EXCEPTION();
5063
5
    }
5064
5
  } while (0);
5065
5066
0
  zend_exception_save();
5067
0
  Z_TRY_ADDREF_P(value);
5068
0
  zend_throw_exception_object(value);
5069
0
  zend_exception_restore();
5070
5071
0
  HANDLE_EXCEPTION();
5072
0
}
5073
5074
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5075
694k
{
5076
694k
  USE_OPLINE
5077
694k
  zend_class_entry *ce, *catch_ce;
5078
694k
  zend_object *exception;
5079
5080
694k
  SAVE_OPLINE();
5081
  /* Check whether an exception has been thrown, if not, jump over code */
5082
694k
  zend_exception_restore();
5083
694k
  if (EG(exception) == NULL) {
5084
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5085
0
  }
5086
694k
  catch_ce = CACHED_PTR(opline->extended_value & ~ZEND_LAST_CATCH);
5087
694k
  if (UNEXPECTED(catch_ce == NULL)) {
5088
425k
    catch_ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD | ZEND_FETCH_CLASS_SILENT);
5089
5090
425k
    CACHE_PTR(opline->extended_value & ~ZEND_LAST_CATCH, catch_ce);
5091
425k
  }
5092
694k
  ce = EG(exception)->ce;
5093
5094
#ifdef HAVE_DTRACE
5095
  if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
5096
    DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
5097
  }
5098
#endif /* HAVE_DTRACE */
5099
5100
694k
  if (ce != catch_ce) {
5101
685k
    if (!catch_ce || !instanceof_function(ce, catch_ce)) {
5102
327k
      if (opline->extended_value & ZEND_LAST_CATCH) {
5103
246k
        zend_rethrow_exception(execute_data);
5104
246k
        HANDLE_EXCEPTION();
5105
246k
      }
5106
81.1k
      ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5107
81.1k
    }
5108
685k
  }
5109
5110
367k
  exception = EG(exception);
5111
367k
  EG(exception) = NULL;
5112
367k
  if (RETURN_VALUE_USED(opline)) {
5113
    /* Always perform a strict assignment. There is a reasonable expectation that if you
5114
     * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
5115
     * we should not permit coercion to string here. */
5116
366k
    zval tmp;
5117
366k
    ZVAL_OBJ(&tmp, exception);
5118
366k
    zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
5119
366k
  } else {
5120
373
    OBJ_RELEASE(exception);
5121
373
  }
5122
367k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5123
367k
}
5124
5125
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5126
249
{
5127
249
  USE_OPLINE
5128
249
  zval *arg, *param;
5129
5130
249
  SAVE_OPLINE();
5131
5132
249
  arg = RT_CONSTANT(opline, opline->op1);
5133
249
  param = ZEND_CALL_VAR(EX(call), opline->result.var);
5134
249
  if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
5135
13
    zend_param_must_be_ref(EX(call)->func, opline->op2.num);
5136
13
    Z_TRY_ADDREF_P(arg);
5137
13
    ZVAL_NEW_REF(param, arg);
5138
236
  } else {
5139
236
    ZVAL_COPY(param, arg);
5140
236
  }
5141
5142
249
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5143
249
}
5144
5145
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5146
1.05k
{
5147
1.05k
  USE_OPLINE
5148
1.05k
  zval *val;
5149
5150
1.05k
  val = RT_CONSTANT(opline, opline->op1);
5151
1.05k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
5152
3
    ZVAL_TRUE(EX_VAR(opline->result.var));
5153
1.05k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
5154
    /* The result and op1 can be the same cv zval */
5155
91
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
5156
91
    ZVAL_FALSE(EX_VAR(opline->result.var));
5157
91
    if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
5158
0
      SAVE_OPLINE();
5159
0
      ZVAL_UNDEFINED_OP1();
5160
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5161
0
    }
5162
962
  } else {
5163
962
    SAVE_OPLINE();
5164
962
    ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
5165
5166
962
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5167
962
  }
5168
94
  ZEND_VM_NEXT_OPCODE();
5169
94
}
5170
5171
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5172
23
{
5173
23
  USE_OPLINE
5174
23
  zval *obj;
5175
23
  zend_object *zobj;
5176
23
  zend_class_entry *ce, *scope;
5177
23
  zend_function *clone;
5178
23
  zend_object_clone_obj_t clone_call;
5179
5180
23
  SAVE_OPLINE();
5181
23
  obj = RT_CONSTANT(opline, opline->op1);
5182
5183
23
  do {
5184
23
    if (IS_CONST == IS_CONST ||
5185
23
        (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
5186
23
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
5187
0
        obj = Z_REFVAL_P(obj);
5188
0
        if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
5189
0
          break;
5190
0
        }
5191
0
      }
5192
23
      ZVAL_UNDEF(EX_VAR(opline->result.var));
5193
23
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
5194
0
        ZVAL_UNDEFINED_OP1();
5195
0
        if (UNEXPECTED(EG(exception) != NULL)) {
5196
0
          HANDLE_EXCEPTION();
5197
0
        }
5198
0
      }
5199
23
      zend_throw_error(NULL, "__clone method called on non-object");
5200
5201
23
      HANDLE_EXCEPTION();
5202
23
    }
5203
23
  } while (0);
5204
5205
0
  zobj = Z_OBJ_P(obj);
5206
0
  ce = zobj->ce;
5207
0
  clone = ce->clone;
5208
0
  clone_call = zobj->handlers->clone_obj;
5209
0
  if (UNEXPECTED(clone_call == NULL)) {
5210
0
    zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
5211
5212
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
5213
0
    HANDLE_EXCEPTION();
5214
0
  }
5215
5216
0
  if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
5217
0
    scope = EX(func)->op_array.scope;
5218
0
    if (clone->common.scope != scope) {
5219
0
      if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
5220
0
       || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
5221
0
        zend_wrong_clone_call(clone, scope);
5222
5223
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
5224
0
        HANDLE_EXCEPTION();
5225
0
      }
5226
0
    }
5227
0
  }
5228
5229
0
  ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
5230
5231
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5232
0
}
5233
5234
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5235
422
{
5236
422
  USE_OPLINE
5237
422
  zval *expr;
5238
422
  zval *result = EX_VAR(opline->result.var);
5239
5240
422
  SAVE_OPLINE();
5241
422
  expr = RT_CONSTANT(opline, opline->op1);
5242
5243
422
  switch (opline->extended_value) {
5244
36
    case IS_LONG:
5245
36
      ZVAL_LONG(result, zval_get_long(expr));
5246
36
      break;
5247
0
    case IS_DOUBLE:
5248
0
      ZVAL_DOUBLE(result, zval_get_double(expr));
5249
0
      break;
5250
108
    case IS_STRING:
5251
108
      ZVAL_STR(result, zval_get_string(expr));
5252
108
      break;
5253
278
    default:
5254
278
      ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
5255
278
      if (IS_CONST & (IS_VAR|IS_CV)) {
5256
0
        ZVAL_DEREF(expr);
5257
0
      }
5258
      /* If value is already of correct type, return it directly */
5259
278
      if (Z_TYPE_P(expr) == opline->extended_value) {
5260
0
        ZVAL_COPY_VALUE(result, expr);
5261
0
        if (IS_CONST == IS_CONST) {
5262
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5263
0
        } else if (IS_CONST != IS_TMP_VAR) {
5264
0
          if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5265
0
        }
5266
5267
0
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5268
0
      }
5269
5270
278
      if (opline->extended_value == IS_ARRAY) {
5271
0
        zend_cast_zval_to_array(result, expr, IS_CONST);
5272
278
      } else {
5273
278
        ZEND_ASSERT(opline->extended_value == IS_OBJECT);
5274
278
        zend_cast_zval_to_object(result, expr, IS_CONST);
5275
278
      }
5276
422
  }
5277
5278
422
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5279
422
}
5280
5281
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5282
117k
{
5283
117k
  USE_OPLINE
5284
117k
  zend_op_array *new_op_array;
5285
117k
  zval *inc_filename;
5286
5287
117k
  SAVE_OPLINE();
5288
117k
  inc_filename = RT_CONSTANT(opline, opline->op1);
5289
117k
  new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5290
117k
  if (UNEXPECTED(EG(exception) != NULL)) {
5291
5292
388
    if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5293
2
      destroy_op_array(new_op_array);
5294
2
      efree_size(new_op_array, sizeof(zend_op_array));
5295
2
    }
5296
388
    UNDEF_RESULT();
5297
388
    HANDLE_EXCEPTION();
5298
117k
  } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5299
0
    if (RETURN_VALUE_USED(opline)) {
5300
0
      ZVAL_TRUE(EX_VAR(opline->result.var));
5301
0
    }
5302
117k
  } else if (UNEXPECTED(new_op_array == NULL)) {
5303
2.18k
    if (RETURN_VALUE_USED(opline)) {
5304
3
      ZVAL_FALSE(EX_VAR(opline->result.var));
5305
3
    }
5306
114k
  } else if (new_op_array->last == 1
5307
114k
      && new_op_array->opcodes[0].opcode == ZEND_RETURN
5308
114k
      && new_op_array->opcodes[0].op1_type == IS_CONST
5309
114k
      && EXPECTED(zend_execute_ex == execute_ex)) {
5310
28.3k
    if (RETURN_VALUE_USED(opline)) {
5311
28.1k
      const zend_op *op = new_op_array->opcodes;
5312
5313
28.1k
      ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5314
28.1k
    }
5315
28.3k
    zend_destroy_static_vars(new_op_array);
5316
28.3k
    destroy_op_array(new_op_array);
5317
28.3k
    efree_size(new_op_array, sizeof(zend_op_array));
5318
86.5k
  } else {
5319
86.5k
    zval *return_value = NULL;
5320
86.5k
    zend_execute_data *call;
5321
86.5k
    if (RETURN_VALUE_USED(opline)) {
5322
84.6k
      return_value = EX_VAR(opline->result.var);
5323
84.6k
    }
5324
5325
86.5k
    new_op_array->scope = EX(func)->op_array.scope;
5326
5327
86.5k
    call = zend_vm_stack_push_call_frame(
5328
86.5k
      (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5329
86.5k
      (zend_function*)new_op_array, 0,
5330
86.5k
      Z_PTR(EX(This)));
5331
5332
86.5k
    if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5333
86.0k
      call->symbol_table = EX(symbol_table);
5334
86.0k
    } else {
5335
446
      call->symbol_table = zend_rebuild_symbol_table();
5336
446
    }
5337
5338
86.5k
    call->prev_execute_data = execute_data;
5339
86.5k
    i_init_code_execute_data(call, new_op_array, return_value);
5340
5341
86.5k
    if (EXPECTED(zend_execute_ex == execute_ex)) {
5342
5343
654
      ZEND_VM_ENTER();
5344
85.8k
    } else {
5345
85.8k
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5346
85.8k
      zend_execute_ex(call);
5347
85.8k
      zend_vm_stack_free_call_frame(call);
5348
85.8k
    }
5349
5350
85.8k
    zend_destroy_static_vars(new_op_array);
5351
85.8k
    destroy_op_array(new_op_array);
5352
85.8k
    efree_size(new_op_array, sizeof(zend_op_array));
5353
85.8k
    if (UNEXPECTED(EG(exception) != NULL)) {
5354
37
      zend_rethrow_exception(execute_data);
5355
5356
37
      UNDEF_RESULT();
5357
37
      HANDLE_EXCEPTION();
5358
37
    }
5359
85.8k
  }
5360
5361
116k
  ZEND_VM_NEXT_OPCODE();
5362
116k
}
5363
5364
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5365
0
{
5366
0
  USE_OPLINE
5367
0
  zend_op_array *new_op_array;
5368
0
  zval *inc_filename;
5369
5370
0
  SAVE_OPLINE();
5371
0
  inc_filename = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
5372
0
  new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5373
0
  if (UNEXPECTED(EG(exception) != NULL)) {
5374
0
    FREE_OP(opline->op1_type, opline->op1.var);
5375
0
    if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5376
0
      destroy_op_array(new_op_array);
5377
0
      efree_size(new_op_array, sizeof(zend_op_array));
5378
0
    }
5379
0
    UNDEF_RESULT();
5380
0
    HANDLE_EXCEPTION();
5381
0
  } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5382
0
    if (RETURN_VALUE_USED(opline)) {
5383
0
      ZVAL_TRUE(EX_VAR(opline->result.var));
5384
0
    }
5385
0
  } else if (UNEXPECTED(new_op_array == NULL)) {
5386
0
    if (RETURN_VALUE_USED(opline)) {
5387
0
      ZVAL_FALSE(EX_VAR(opline->result.var));
5388
0
    }
5389
0
  } else if (new_op_array->last == 1
5390
0
      && new_op_array->opcodes[0].opcode == ZEND_RETURN
5391
0
      && new_op_array->opcodes[0].op1_type == IS_CONST
5392
0
      && EXPECTED(zend_execute_ex == execute_ex)) {
5393
0
    if (RETURN_VALUE_USED(opline)) {
5394
0
      const zend_op *op = new_op_array->opcodes;
5395
5396
0
      ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5397
0
    }
5398
0
    zend_destroy_static_vars(new_op_array);
5399
0
    destroy_op_array(new_op_array);
5400
0
    efree_size(new_op_array, sizeof(zend_op_array));
5401
0
  } else {
5402
0
    zval *return_value = NULL;
5403
0
    zend_execute_data *call;
5404
0
    if (RETURN_VALUE_USED(opline)) {
5405
0
      return_value = EX_VAR(opline->result.var);
5406
0
    }
5407
5408
0
    new_op_array->scope = EX(func)->op_array.scope;
5409
5410
0
    call = zend_vm_stack_push_call_frame(
5411
0
      (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5412
0
      (zend_function*)new_op_array, 0,
5413
0
      Z_PTR(EX(This)));
5414
5415
0
    if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5416
0
      call->symbol_table = EX(symbol_table);
5417
0
    } else {
5418
0
      call->symbol_table = zend_rebuild_symbol_table();
5419
0
    }
5420
5421
0
    call->prev_execute_data = execute_data;
5422
0
    i_init_code_execute_data(call, new_op_array, return_value);
5423
0
    zend_observer_fcall_begin_specialized(call, false);
5424
0
    if (EXPECTED(zend_execute_ex == execute_ex)) {
5425
0
      FREE_OP(opline->op1_type, opline->op1.var);
5426
0
      ZEND_VM_ENTER();
5427
0
    } else {
5428
0
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5429
0
      zend_execute_ex(call);
5430
0
      zend_vm_stack_free_call_frame(call);
5431
0
    }
5432
5433
0
    zend_destroy_static_vars(new_op_array);
5434
0
    destroy_op_array(new_op_array);
5435
0
    efree_size(new_op_array, sizeof(zend_op_array));
5436
0
    if (UNEXPECTED(EG(exception) != NULL)) {
5437
0
      zend_rethrow_exception(execute_data);
5438
0
      FREE_OP(opline->op1_type, opline->op1.var);
5439
0
      UNDEF_RESULT();
5440
0
      HANDLE_EXCEPTION();
5441
0
    }
5442
0
  }
5443
0
  FREE_OP(opline->op1_type, opline->op1.var);
5444
0
  ZEND_VM_NEXT_OPCODE();
5445
0
}
5446
5447
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5448
484
{
5449
484
  USE_OPLINE
5450
484
  zval *array_ptr, *result;
5451
5452
484
  SAVE_OPLINE();
5453
5454
484
  array_ptr = RT_CONSTANT(opline, opline->op1);
5455
484
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5456
479
    result = EX_VAR(opline->result.var);
5457
479
    ZVAL_COPY_VALUE(result, array_ptr);
5458
479
    if (IS_CONST != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
5459
0
      Z_ADDREF_P(array_ptr);
5460
0
    }
5461
479
    Z_FE_POS_P(result) = 0;
5462
5463
479
    ZEND_VM_NEXT_OPCODE();
5464
479
  } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5465
0
    zend_object *zobj = Z_OBJ_P(array_ptr);
5466
0
    if (!zobj->ce->get_iterator) {
5467
0
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
5468
0
        zobj = zend_lazy_object_init(zobj);
5469
0
        if (UNEXPECTED(EG(exception))) {
5470
0
          UNDEF_RESULT();
5471
5472
0
          HANDLE_EXCEPTION();
5473
0
        }
5474
0
      }
5475
0
      HashTable *properties = zobj->properties;
5476
0
      if (properties) {
5477
0
        if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
5478
0
          if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
5479
0
            GC_DELREF(properties);
5480
0
          }
5481
0
          properties = zobj->properties = zend_array_dup(properties);
5482
0
        }
5483
0
      } else {
5484
0
        properties = zobj->handlers->get_properties(zobj);
5485
0
      }
5486
5487
0
      result = EX_VAR(opline->result.var);
5488
0
      ZVAL_COPY_VALUE(result, array_ptr);
5489
0
      if (IS_CONST != IS_TMP_VAR) {
5490
0
        Z_ADDREF_P(array_ptr);
5491
0
      }
5492
5493
0
      if (zend_hash_num_elements(properties) == 0) {
5494
0
        Z_FE_ITER_P(result) = (uint32_t) -1;
5495
5496
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5497
0
      }
5498
5499
0
      Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
5500
5501
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5502
0
    } else {
5503
0
      bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
5504
5505
0
      if (UNEXPECTED(EG(exception))) {
5506
0
        HANDLE_EXCEPTION();
5507
0
      } else if (is_empty) {
5508
0
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5509
0
      } else {
5510
0
        ZEND_VM_NEXT_OPCODE();
5511
0
      }
5512
0
    }
5513
5
  } else {
5514
5
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5515
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
5516
5
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5517
5518
5
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5519
5
  }
5520
484
}
5521
5522
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5523
102
{
5524
102
  USE_OPLINE
5525
102
  zval *array_ptr, *array_ref;
5526
5527
102
  SAVE_OPLINE();
5528
5529
102
  if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5530
0
    array_ref = array_ptr = zend_get_bad_ptr();
5531
0
    if (Z_ISREF_P(array_ref)) {
5532
0
      array_ptr = Z_REFVAL_P(array_ref);
5533
0
    }
5534
102
  } else {
5535
102
    array_ref = array_ptr = RT_CONSTANT(opline, opline->op1);
5536
102
  }
5537
5538
102
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5539
102
    if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5540
0
      if (array_ptr == array_ref) {
5541
0
        ZVAL_NEW_REF(array_ref, array_ref);
5542
0
        array_ptr = Z_REFVAL_P(array_ref);
5543
0
      }
5544
0
      Z_ADDREF_P(array_ref);
5545
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5546
102
    } else {
5547
102
      array_ref = EX_VAR(opline->result.var);
5548
102
      ZVAL_NEW_REF(array_ref, array_ptr);
5549
102
      array_ptr = Z_REFVAL_P(array_ref);
5550
102
    }
5551
102
    if (IS_CONST == IS_CONST) {
5552
102
      ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
5553
102
    } else {
5554
0
      SEPARATE_ARRAY(array_ptr);
5555
0
    }
5556
102
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
5557
5558
102
    ZEND_VM_NEXT_OPCODE();
5559
102
  } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5560
0
    if (!Z_OBJCE_P(array_ptr)->get_iterator) {
5561
0
      zend_object *zobj = Z_OBJ_P(array_ptr);
5562
0
      HashTable *properties;
5563
0
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
5564
0
        zobj = zend_lazy_object_init(zobj);
5565
0
        if (UNEXPECTED(EG(exception))) {
5566
0
          UNDEF_RESULT();
5567
5568
0
          HANDLE_EXCEPTION();
5569
0
        }
5570
0
      }
5571
0
      if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5572
0
        if (array_ptr == array_ref) {
5573
0
          ZVAL_NEW_REF(array_ref, array_ref);
5574
0
          array_ptr = Z_REFVAL_P(array_ref);
5575
0
        }
5576
0
        Z_ADDREF_P(array_ref);
5577
0
        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5578
0
      } else {
5579
0
        array_ptr = EX_VAR(opline->result.var);
5580
0
        ZVAL_COPY_VALUE(array_ptr, array_ref);
5581
0
      }
5582
0
      if (Z_OBJ_P(array_ptr)->properties
5583
0
       && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
5584
0
        if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
5585
0
          GC_DELREF(Z_OBJ_P(array_ptr)->properties);
5586
0
        }
5587
0
        Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
5588
0
      }
5589
5590
0
      properties = Z_OBJPROP_P(array_ptr);
5591
0
      if (zend_hash_num_elements(properties) == 0) {
5592
0
        Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
5593
5594
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5595
0
      }
5596
5597
0
      Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
5598
5599
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5600
0
    } else {
5601
0
      bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
5602
5603
0
      if (UNEXPECTED(EG(exception))) {
5604
0
        HANDLE_EXCEPTION();
5605
0
      } else if (is_empty) {
5606
0
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5607
0
      } else {
5608
0
        ZEND_VM_NEXT_OPCODE();
5609
0
      }
5610
0
    }
5611
0
  } else {
5612
0
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5613
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
5614
0
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5615
5616
0
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5617
0
  }
5618
102
}
5619
5620
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5621
10
{
5622
10
  USE_OPLINE
5623
10
  zval *value;
5624
10
  zend_reference *ref = NULL;
5625
10
  bool ret;
5626
5627
10
  SAVE_OPLINE();
5628
10
  value = RT_CONSTANT(opline, opline->op1);
5629
5630
10
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) {
5631
0
    if (IS_CONST == IS_VAR) {
5632
0
      ref = Z_REF_P(value);
5633
0
    }
5634
0
    value = Z_REFVAL_P(value);
5635
0
  }
5636
5637
10
  ret = i_zend_is_true(value);
5638
5639
10
  if (UNEXPECTED(EG(exception))) {
5640
5641
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
5642
0
    HANDLE_EXCEPTION();
5643
0
  }
5644
5645
10
  if (ret) {
5646
5
    zval *result = EX_VAR(opline->result.var);
5647
5648
5
    ZVAL_COPY_VALUE(result, value);
5649
5
    if (IS_CONST == IS_CONST) {
5650
5
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5651
5
    } else if (IS_CONST == IS_CV) {
5652
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5653
0
    } else if (IS_CONST == IS_VAR && ref) {
5654
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5655
0
        efree_size(ref, sizeof(zend_reference));
5656
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
5657
0
        Z_ADDREF_P(result);
5658
0
      }
5659
0
    }
5660
5
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5661
5
  }
5662
5663
5
  ZEND_VM_NEXT_OPCODE();
5664
5
}
5665
5666
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5667
75
{
5668
75
  USE_OPLINE
5669
75
  zval *value;
5670
75
  zend_reference *ref = NULL;
5671
5672
75
  SAVE_OPLINE();
5673
75
  value = RT_CONSTANT(opline, opline->op1);
5674
5675
75
  if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
5676
0
    if (IS_CONST & IS_VAR) {
5677
0
      ref = Z_REF_P(value);
5678
0
    }
5679
0
    value = Z_REFVAL_P(value);
5680
0
  }
5681
5682
75
  if (Z_TYPE_P(value) > IS_NULL) {
5683
60
    zval *result = EX_VAR(opline->result.var);
5684
60
    ZVAL_COPY_VALUE(result, value);
5685
60
    if (IS_CONST == IS_CONST) {
5686
60
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5687
60
    } else if (IS_CONST == IS_CV) {
5688
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5689
0
    } else if ((IS_CONST & IS_VAR) && ref) {
5690
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5691
0
        efree_size(ref, sizeof(zend_reference));
5692
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
5693
0
        Z_ADDREF_P(result);
5694
0
      }
5695
0
    }
5696
60
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5697
60
  }
5698
5699
15
  if ((IS_CONST & IS_VAR) && ref) {
5700
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5701
0
      efree_size(ref, sizeof(zend_reference));
5702
0
    }
5703
0
  }
5704
15
  ZEND_VM_NEXT_OPCODE();
5705
15
}
5706
5707
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5708
230
{
5709
230
  USE_OPLINE
5710
230
  zval *val, *result;
5711
5712
230
  val = RT_CONSTANT(opline, opline->op1);
5713
5714
230
  if (Z_TYPE_P(val) > IS_NULL) {
5715
53
    do {
5716
53
      if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
5717
0
        val = Z_REFVAL_P(val);
5718
0
        if (Z_TYPE_P(val) <= IS_NULL) {
5719
5720
0
          break;
5721
0
        }
5722
0
      }
5723
53
      ZEND_VM_NEXT_OPCODE();
5724
53
    } while (0);
5725
53
  }
5726
5727
177
  result = EX_VAR(opline->result.var);
5728
177
  uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
5729
177
  if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
5730
177
    ZVAL_NULL(result);
5731
177
    if (IS_CONST == IS_CV
5732
177
      && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
5733
177
      && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
5734
177
    ) {
5735
0
      SAVE_OPLINE();
5736
0
      ZVAL_UNDEFINED_OP1();
5737
0
      if (UNEXPECTED(EG(exception) != NULL)) {
5738
0
        HANDLE_EXCEPTION();
5739
0
      }
5740
0
    }
5741
177
  } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
5742
0
    ZVAL_FALSE(result);
5743
0
  } else {
5744
0
    ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
5745
0
    ZVAL_TRUE(result);
5746
0
  }
5747
5748
177
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5749
177
}
5750
5751
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5752
0
{
5753
0
  USE_OPLINE
5754
0
  zval *value;
5755
0
  zval *result = EX_VAR(opline->result.var);
5756
5757
0
  value = RT_CONSTANT(opline, opline->op1);
5758
0
  if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5759
0
    SAVE_OPLINE();
5760
0
    ZVAL_UNDEFINED_OP1();
5761
0
    ZVAL_NULL(result);
5762
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5763
0
  }
5764
5765
0
  if (IS_CONST == IS_CV) {
5766
0
    ZVAL_COPY_DEREF(result, value);
5767
0
  } else if (IS_CONST == IS_VAR) {
5768
0
    if (UNEXPECTED(Z_ISREF_P(value))) {
5769
0
      ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
5770
0
      if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
5771
0
        efree_size(Z_REF_P(value), sizeof(zend_reference));
5772
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
5773
0
        Z_ADDREF_P(result);
5774
0
      }
5775
0
    } else {
5776
0
      ZVAL_COPY_VALUE(result, value);
5777
0
    }
5778
0
  } else {
5779
0
    ZVAL_COPY_VALUE(result, value);
5780
0
    if (IS_CONST == IS_CONST) {
5781
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
5782
0
        Z_ADDREF_P(result);
5783
0
      }
5784
0
    }
5785
0
  }
5786
0
  ZEND_VM_NEXT_OPCODE();
5787
0
}
5788
5789
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5790
5.88k
{
5791
5.88k
  USE_OPLINE
5792
5793
5.88k
  SAVE_OPLINE();
5794
5.88k
  do_bind_class(RT_CONSTANT(opline, opline->op1), (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL);
5795
5.88k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5796
5.88k
}
5797
5798
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5799
11.9k
{
5800
11.9k
  USE_OPLINE
5801
11.9k
  zend_function *func;
5802
11.9k
  zval *object;
5803
11.9k
  zend_class_entry *called_scope;
5804
5805
11.9k
  func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
5806
11.9k
  if (Z_TYPE(EX(This)) == IS_OBJECT) {
5807
2.33k
    called_scope = Z_OBJCE(EX(This));
5808
2.33k
    if (UNEXPECTED((func->common.fn_flags & ZEND_ACC_STATIC) ||
5809
2.33k
        (EX(func)->common.fn_flags & ZEND_ACC_STATIC))) {
5810
50
      object = NULL;
5811
2.28k
    } else {
5812
2.28k
      object = &EX(This);
5813
2.28k
    }
5814
9.65k
  } else {
5815
9.65k
    called_scope = Z_CE(EX(This));
5816
9.65k
    object = NULL;
5817
9.65k
  }
5818
11.9k
  SAVE_OPLINE();
5819
11.9k
  zend_create_closure(EX_VAR(opline->result.var), func,
5820
11.9k
    EX(func)->op_array.scope, called_scope, object);
5821
5822
11.9k
  ZEND_VM_NEXT_OPCODE();
5823
11.9k
}
5824
5825
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5826
40
{
5827
40
  USE_OPLINE
5828
40
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
5829
40
  zval *val;
5830
5831
40
  SAVE_OPLINE();
5832
40
  val = RT_CONSTANT(opline, opline->op1);
5833
5834
40
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
5835
0
    zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
5836
5837
0
    UNDEF_RESULT();
5838
0
    HANDLE_EXCEPTION();
5839
0
  }
5840
5841
40
yield_from_try_again:
5842
40
  if (Z_TYPE_P(val) == IS_ARRAY) {
5843
40
    ZVAL_COPY_VALUE(&generator->values, val);
5844
40
    if (Z_OPT_REFCOUNTED_P(val)) {
5845
1
      Z_ADDREF_P(val);
5846
1
    }
5847
40
    Z_FE_POS(generator->values) = 0;
5848
5849
40
  } else if (IS_CONST != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
5850
0
    zend_class_entry *ce = Z_OBJCE_P(val);
5851
0
    if (ce == zend_ce_generator) {
5852
0
      zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
5853
5854
0
      Z_ADDREF_P(val);
5855
5856
0
      if (UNEXPECTED(new_gen->execute_data == NULL)) {
5857
0
        zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
5858
0
        zval_ptr_dtor(val);
5859
0
        UNDEF_RESULT();
5860
0
        HANDLE_EXCEPTION();
5861
0
      } else if (Z_ISUNDEF(new_gen->retval)) {
5862
0
        if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
5863
0
          zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
5864
0
          zval_ptr_dtor(val);
5865
0
          UNDEF_RESULT();
5866
0
          HANDLE_EXCEPTION();
5867
0
        } else {
5868
0
          zend_generator_yield_from(generator, new_gen);
5869
0
        }
5870
0
      } else {
5871
0
        if (RETURN_VALUE_USED(opline)) {
5872
0
          ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
5873
0
        }
5874
0
        ZEND_VM_NEXT_OPCODE();
5875
0
      }
5876
0
    } else {
5877
0
      zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
5878
5879
0
      if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
5880
0
        if (!EG(exception)) {
5881
0
          zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
5882
0
        }
5883
0
        UNDEF_RESULT();
5884
0
        HANDLE_EXCEPTION();
5885
0
      }
5886
5887
0
      iter->index = 0;
5888
0
      if (iter->funcs->rewind) {
5889
0
        iter->funcs->rewind(iter);
5890
0
        if (UNEXPECTED(EG(exception) != NULL)) {
5891
0
          OBJ_RELEASE(&iter->std);
5892
0
          UNDEF_RESULT();
5893
0
          HANDLE_EXCEPTION();
5894
0
        }
5895
0
      }
5896
5897
0
      ZVAL_OBJ(&generator->values, &iter->std);
5898
0
    }
5899
0
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
5900
0
    val = Z_REFVAL_P(val);
5901
0
    goto yield_from_try_again;
5902
0
  } else {
5903
0
    zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
5904
5905
0
    UNDEF_RESULT();
5906
0
    HANDLE_EXCEPTION();
5907
0
  }
5908
5909
  /* This is the default return value
5910
   * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
5911
40
  if (RETURN_VALUE_USED(opline)) {
5912
40
    ZVAL_NULL(EX_VAR(opline->result.var));
5913
40
  }
5914
5915
  /* This generator has no send target (though the generator we delegate to might have one) */
5916
40
  generator->send_target = NULL;
5917
5918
  /* The GOTO VM uses a local opline variable. We need to set the opline
5919
   * variable in execute_data so we don't resume at an old position. */
5920
40
  SAVE_OPLINE();
5921
5922
40
  ZEND_VM_RETURN();
5923
40
}
5924
5925
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5926
15
{
5927
15
  USE_OPLINE
5928
15
  zval *value;
5929
5930
15
  value = RT_CONSTANT(opline, opline->op1);
5931
15
  if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5932
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5933
0
    if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
5934
0
      zval_ptr_dtor_str(value);
5935
0
    }
5936
0
    ZEND_VM_NEXT_OPCODE();
5937
15
  } else {
5938
15
    bool strict;
5939
5940
15
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
5941
0
      value = Z_REFVAL_P(value);
5942
0
      if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5943
0
        ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5944
5945
0
        ZEND_VM_NEXT_OPCODE();
5946
0
      }
5947
0
    }
5948
5949
15
    SAVE_OPLINE();
5950
15
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5951
0
      value = ZVAL_UNDEFINED_OP1();
5952
0
    }
5953
15
    strict = EX_USES_STRICT_TYPES();
5954
15
    do {
5955
15
      if (EXPECTED(!strict)) {
5956
10
        zend_string *str;
5957
10
        zval tmp;
5958
5959
10
        if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
5960
8
          zend_error(E_DEPRECATED,
5961
8
            "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
5962
8
          ZVAL_LONG(EX_VAR(opline->result.var), 0);
5963
8
          if (UNEXPECTED(EG(exception))) {
5964
5
            HANDLE_EXCEPTION();
5965
5
          }
5966
3
          break;
5967
8
        }
5968
5969
2
        ZVAL_COPY(&tmp, value);
5970
2
        if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
5971
2
          ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
5972
2
          zval_ptr_dtor(&tmp);
5973
2
          break;
5974
2
        }
5975
0
        zval_ptr_dtor(&tmp);
5976
0
      }
5977
5
      if (!EG(exception)) {
5978
5
        zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
5979
5
      }
5980
5
      ZVAL_UNDEF(EX_VAR(opline->result.var));
5981
5
    } while (0);
5982
15
  }
5983
5984
10
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5985
10
}
5986
5987
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5988
22
{
5989
22
  USE_OPLINE
5990
22
  zval *value;
5991
22
  int result = 0;
5992
5993
22
  value = RT_CONSTANT(opline, opline->op1);
5994
22
  if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
5995
22
type_check_resource:
5996
22
    if (opline->extended_value != MAY_BE_RESOURCE
5997
22
     || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
5998
22
      result = 1;
5999
22
    }
6000
22
  } else if ((IS_CONST & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
6001
0
    value = Z_REFVAL_P(value);
6002
0
    if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
6003
0
      goto type_check_resource;
6004
0
    }
6005
0
  } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
6006
0
    result = ((1 << IS_NULL) & opline->extended_value) != 0;
6007
0
    SAVE_OPLINE();
6008
0
    ZVAL_UNDEFINED_OP1();
6009
0
    if (UNEXPECTED(EG(exception))) {
6010
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
6011
0
      HANDLE_EXCEPTION();
6012
0
    }
6013
0
  }
6014
22
  if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6015
0
    SAVE_OPLINE();
6016
6017
0
    ZEND_VM_SMART_BRANCH(result, 1);
6018
22
  } else {
6019
22
    ZEND_VM_SMART_BRANCH(result, 0);
6020
22
  }
6021
22
}
6022
6023
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6024
1.47k
{
6025
1.47k
  USE_OPLINE
6026
1.47k
  zend_constant *c;
6027
6028
1.47k
  c = CACHED_PTR(opline->extended_value);
6029
1.47k
  if (EXPECTED(c != NULL)) {
6030
1.41k
    if (!IS_SPECIAL_CACHE_VAL(c)) {
6031
35
defined_true:
6032
35
      ZEND_VM_SMART_BRANCH_TRUE();
6033
1.40k
    } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
6034
1.44k
defined_false:
6035
1.44k
      ZEND_VM_SMART_BRANCH_FALSE();
6036
1.44k
    }
6037
1.41k
  }
6038
69
  if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
6039
45
    CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
6040
45
    goto defined_false;
6041
45
  } else {
6042
24
    goto defined_true;
6043
24
  }
6044
69
}
6045
6046
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6047
0
{
6048
0
  USE_OPLINE
6049
0
  zend_jmp_fl_result result = (uintptr_t)CACHED_PTR(opline->extended_value);
6050
0
try_again:
6051
0
  if (EXPECTED(result == ZEND_JMP_FL_HIT)) {
6052
0
    OPLINE = OP_JMP_ADDR(opline, opline->op2);
6053
0
    ZEND_VM_CONTINUE();
6054
0
  } else if (EXPECTED(result == ZEND_JMP_FL_MISS)) {
6055
0
    ZEND_VM_NEXT_OPCODE();
6056
0
  } else {
6057
0
    ZEND_ASSERT(result == ZEND_JMP_FL_UNPRIMED);
6058
    /* func_name refers to the function in the local namespace, e.g. foo\substr. */
6059
0
    zval *func_name = (zval *)RT_CONSTANT(opline, opline->op1);
6060
    /* If it cannot be found locally, we must be referring to the global function. */
6061
0
    zval *func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name));
6062
    /* ZEND_JMP_FL_MISS = 1, ZEND_JMP_FL_HIT = 2 */
6063
0
    result = (func == NULL) + 1;
6064
0
    CACHE_PTR(opline->extended_value, (void *)result);
6065
0
    goto try_again;
6066
0
  }
6067
0
}
6068
6069
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6070
0
{
6071
0
  USE_OPLINE
6072
0
  zval *value;
6073
6074
0
  value = RT_CONSTANT(opline, opline->op1);
6075
0
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
6076
0
  ZEND_VM_NEXT_OPCODE();
6077
0
}
6078
6079
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6080
0
{
6081
0
  USE_OPLINE
6082
0
  zval *value;
6083
6084
0
  value = RT_CONSTANT(opline, opline->op1);
6085
0
  ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
6086
0
  ZEND_VM_NEXT_OPCODE();
6087
0
}
6088
6089
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6090
15.1k
{
6091
15.1k
  USE_OPLINE
6092
15.1k
  zval *value;
6093
6094
15.1k
  value = RT_CONSTANT(opline, opline->op1);
6095
15.1k
  ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
6096
15.1k
  ZEND_VM_NEXT_OPCODE();
6097
15.1k
}
6098
6099
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6100
64.0k
{
6101
64.0k
  USE_OPLINE
6102
64.0k
  zval *value, *arg;
6103
6104
64.0k
  value = RT_CONSTANT(opline, opline->op1);
6105
64.0k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
6106
64.0k
  ZVAL_COPY_VALUE(arg, value);
6107
64.0k
  ZEND_VM_NEXT_OPCODE();
6108
64.0k
}
6109
6110
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6111
95.8k
{
6112
95.8k
  USE_OPLINE
6113
95.8k
  zval *value, *arg;
6114
95.8k
  uint32_t arg_num = opline->op2.num;
6115
6116
95.8k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
6117
95.8k
  if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
6118
29
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
6119
29
  }
6120
95.8k
  value = RT_CONSTANT(opline, opline->op1);
6121
95.8k
  ZVAL_COPY_VALUE(arg, value);
6122
95.8k
  ZEND_VM_NEXT_OPCODE();
6123
95.8k
}
6124
6125
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6126
779
{
6127
779
  USE_OPLINE
6128
779
  zval *op1, *op2, *result;
6129
779
  double d1, d2;
6130
6131
779
  op1 = RT_CONSTANT(opline, opline->op1);
6132
779
  op2 = RT_CONSTANT(opline, opline->op2);
6133
779
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6134
    /* pass */
6135
779
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6136
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6137
0
      result = EX_VAR(opline->result.var);
6138
0
      fast_long_add_function(result, op1, op2);
6139
0
      ZEND_VM_NEXT_OPCODE();
6140
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6141
0
      d1 = (double)Z_LVAL_P(op1);
6142
0
      d2 = Z_DVAL_P(op2);
6143
0
      goto add_double;
6144
0
    }
6145
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6146
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6147
0
      d1 = Z_DVAL_P(op1);
6148
0
      d2 = Z_DVAL_P(op2);
6149
0
add_double:
6150
0
      result = EX_VAR(opline->result.var);
6151
0
      ZVAL_DOUBLE(result, d1 + d2);
6152
0
      ZEND_VM_NEXT_OPCODE();
6153
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6154
0
      d1 = Z_DVAL_P(op1);
6155
0
      d2 = (double)Z_LVAL_P(op2);
6156
0
      goto add_double;
6157
0
    }
6158
0
  }
6159
6160
779
  ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6161
779
}
6162
6163
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6164
1.26k
{
6165
1.26k
  USE_OPLINE
6166
1.26k
  zval *op1, *op2, *result;
6167
1.26k
  double d1, d2;
6168
6169
1.26k
  op1 = RT_CONSTANT(opline, opline->op1);
6170
1.26k
  op2 = RT_CONSTANT(opline, opline->op2);
6171
1.26k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6172
    /* pass */
6173
1.26k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6174
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6175
0
      result = EX_VAR(opline->result.var);
6176
0
      fast_long_sub_function(result, op1, op2);
6177
0
      ZEND_VM_NEXT_OPCODE();
6178
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6179
0
      d1 = (double)Z_LVAL_P(op1);
6180
0
      d2 = Z_DVAL_P(op2);
6181
0
      goto sub_double;
6182
0
    }
6183
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6184
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6185
0
      d1 = Z_DVAL_P(op1);
6186
0
      d2 = Z_DVAL_P(op2);
6187
0
sub_double:
6188
0
      result = EX_VAR(opline->result.var);
6189
0
      ZVAL_DOUBLE(result, d1 - d2);
6190
0
      ZEND_VM_NEXT_OPCODE();
6191
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6192
0
      d1 = Z_DVAL_P(op1);
6193
0
      d2 = (double)Z_LVAL_P(op2);
6194
0
      goto sub_double;
6195
0
    }
6196
0
  }
6197
6198
1.26k
  ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6199
1.26k
}
6200
6201
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6202
4.11k
{
6203
4.11k
  USE_OPLINE
6204
4.11k
  zval *op1, *op2, *result;
6205
4.11k
  double d1, d2;
6206
6207
4.11k
  op1 = RT_CONSTANT(opline, opline->op1);
6208
4.11k
  op2 = RT_CONSTANT(opline, opline->op2);
6209
4.11k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6210
    /* pass */
6211
4.11k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6212
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6213
0
      zend_long overflow;
6214
6215
0
      result = EX_VAR(opline->result.var);
6216
0
      ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
6217
0
      Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
6218
0
      ZEND_VM_NEXT_OPCODE();
6219
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6220
0
      d1 = (double)Z_LVAL_P(op1);
6221
0
      d2 = Z_DVAL_P(op2);
6222
0
      goto mul_double;
6223
0
    }
6224
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6225
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6226
0
      d1 = Z_DVAL_P(op1);
6227
0
      d2 = Z_DVAL_P(op2);
6228
0
mul_double:
6229
0
      result = EX_VAR(opline->result.var);
6230
0
      ZVAL_DOUBLE(result, d1 * d2);
6231
0
      ZEND_VM_NEXT_OPCODE();
6232
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6233
0
      d1 = Z_DVAL_P(op1);
6234
0
      d2 = (double)Z_LVAL_P(op2);
6235
0
      goto mul_double;
6236
0
    }
6237
0
  }
6238
6239
4.11k
  ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6240
4.11k
}
6241
6242
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6243
158
{
6244
158
  USE_OPLINE
6245
158
  zval *op1, *op2;
6246
6247
158
  SAVE_OPLINE();
6248
158
  op1 = RT_CONSTANT(opline, opline->op1);
6249
158
  op2 = RT_CONSTANT(opline, opline->op2);
6250
158
  div_function(EX_VAR(opline->result.var), op1, op2);
6251
6252
6253
158
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6254
158
}
6255
6256
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6257
17.9k
{
6258
17.9k
  USE_OPLINE
6259
17.9k
  zval *op1, *op2, *result;
6260
6261
17.9k
  op1 = RT_CONSTANT(opline, opline->op1);
6262
17.9k
  op2 = RT_CONSTANT(opline, opline->op2);
6263
17.9k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6264
    /* pass */
6265
17.9k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6266
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6267
0
      result = EX_VAR(opline->result.var);
6268
0
      if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
6269
0
        ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6270
0
      } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
6271
        /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
6272
0
        ZVAL_LONG(result, 0);
6273
0
      } else {
6274
0
        ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
6275
0
      }
6276
0
      ZEND_VM_NEXT_OPCODE();
6277
0
    }
6278
0
  }
6279
6280
17.9k
  ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6281
17.9k
}
6282
6283
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6284
1.12k
{
6285
1.12k
  USE_OPLINE
6286
1.12k
  zval *op1, *op2;
6287
6288
1.12k
  op1 = RT_CONSTANT(opline, opline->op1);
6289
1.12k
  op2 = RT_CONSTANT(opline, opline->op2);
6290
1.12k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6291
    /* pass */
6292
1.12k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6293
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6294
0
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6295
    /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
6296
0
    ZVAL_LONG(EX_VAR(opline->result.var),
6297
0
      (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
6298
0
    ZEND_VM_NEXT_OPCODE();
6299
0
  }
6300
6301
1.12k
  ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6302
1.12k
}
6303
6304
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6305
99
{
6306
99
  USE_OPLINE
6307
99
  zval *op1, *op2;
6308
6309
99
  op1 = RT_CONSTANT(opline, opline->op1);
6310
99
  op2 = RT_CONSTANT(opline, opline->op2);
6311
99
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6312
    /* pass */
6313
99
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6314
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6315
0
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6316
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
6317
0
    ZEND_VM_NEXT_OPCODE();
6318
0
  }
6319
6320
99
  ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6321
99
}
6322
6323
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6324
307
{
6325
307
  USE_OPLINE
6326
307
  zval *op1, *op2;
6327
6328
307
  SAVE_OPLINE();
6329
307
  op1 = RT_CONSTANT(opline, opline->op1);
6330
307
  op2 = RT_CONSTANT(opline, opline->op2);
6331
307
  pow_function(EX_VAR(opline->result.var), op1, op2);
6332
6333
6334
307
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6335
307
}
6336
6337
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6338
49
{
6339
49
  USE_OPLINE
6340
49
  zval *op1, *op2;
6341
49
  bool result;
6342
6343
49
  SAVE_OPLINE();
6344
49
  op1 = RT_CONSTANT(opline, opline->op1);
6345
49
  op2 = RT_CONSTANT(opline, opline->op2);
6346
49
  result = fast_is_identical_function(op1, op2);
6347
6348
6349
49
  ZEND_VM_SMART_BRANCH(result, 1);
6350
49
}
6351
6352
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6353
2
{
6354
2
  USE_OPLINE
6355
2
  zval *op1, *op2;
6356
2
  bool result;
6357
6358
2
  SAVE_OPLINE();
6359
2
  op1 = RT_CONSTANT(opline, opline->op1);
6360
2
  op2 = RT_CONSTANT(opline, opline->op2);
6361
2
  result = fast_is_not_identical_function(op1, op2);
6362
6363
6364
2
  ZEND_VM_SMART_BRANCH(result, 1);
6365
2
}
6366
6367
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6368
82
{
6369
82
  USE_OPLINE
6370
82
  zval *op1, *op2;
6371
82
  double d1, d2;
6372
6373
82
  op1 = RT_CONSTANT(opline, opline->op1);
6374
82
  op2 = RT_CONSTANT(opline, opline->op2);
6375
82
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6376
    /* pass */
6377
82
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6378
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6379
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
6380
0
is_equal_true:
6381
0
        ZEND_VM_SMART_BRANCH_TRUE();
6382
0
      } else {
6383
0
is_equal_false:
6384
0
        ZEND_VM_SMART_BRANCH_FALSE();
6385
0
      }
6386
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6387
0
      d1 = (double)Z_LVAL_P(op1);
6388
0
      d2 = Z_DVAL_P(op2);
6389
0
      goto is_equal_double;
6390
0
    }
6391
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6392
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6393
0
      d1 = Z_DVAL_P(op1);
6394
0
      d2 = Z_DVAL_P(op2);
6395
0
is_equal_double:
6396
0
      if (d1 == d2) {
6397
0
        goto is_equal_true;
6398
0
      } else {
6399
0
        goto is_equal_false;
6400
0
      }
6401
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6402
0
      d1 = Z_DVAL_P(op1);
6403
0
      d2 = (double)Z_LVAL_P(op2);
6404
0
      goto is_equal_double;
6405
0
    }
6406
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6407
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6408
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6409
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6410
0
        zval_ptr_dtor_str(op1);
6411
0
      }
6412
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6413
0
        zval_ptr_dtor_str(op2);
6414
0
      }
6415
0
      if (result) {
6416
0
        goto is_equal_true;
6417
0
      } else {
6418
0
        goto is_equal_false;
6419
0
      }
6420
0
    }
6421
0
  }
6422
82
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6423
82
}
6424
6425
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6426
0
{
6427
0
  USE_OPLINE
6428
0
  zval *op1, *op2;
6429
0
  double d1, d2;
6430
6431
0
  op1 = RT_CONSTANT(opline, opline->op1);
6432
0
  op2 = RT_CONSTANT(opline, opline->op2);
6433
0
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6434
    /* pass */
6435
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6436
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6437
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
6438
0
is_not_equal_true:
6439
0
        ZEND_VM_SMART_BRANCH_TRUE();
6440
0
      } else {
6441
0
is_not_equal_false:
6442
0
        ZEND_VM_SMART_BRANCH_FALSE();
6443
0
      }
6444
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6445
0
      d1 = (double)Z_LVAL_P(op1);
6446
0
      d2 = Z_DVAL_P(op2);
6447
0
      goto is_not_equal_double;
6448
0
    }
6449
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6450
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6451
0
      d1 = Z_DVAL_P(op1);
6452
0
      d2 = Z_DVAL_P(op2);
6453
0
is_not_equal_double:
6454
0
      if (d1 != d2) {
6455
0
        goto is_not_equal_true;
6456
0
      } else {
6457
0
        goto is_not_equal_false;
6458
0
      }
6459
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6460
0
      d1 = Z_DVAL_P(op1);
6461
0
      d2 = (double)Z_LVAL_P(op2);
6462
0
      goto is_not_equal_double;
6463
0
    }
6464
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6465
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6466
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6467
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6468
0
        zval_ptr_dtor_str(op1);
6469
0
      }
6470
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6471
0
        zval_ptr_dtor_str(op2);
6472
0
      }
6473
0
      if (!result) {
6474
0
        goto is_not_equal_true;
6475
0
      } else {
6476
0
        goto is_not_equal_false;
6477
0
      }
6478
0
    }
6479
0
  }
6480
0
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6481
0
}
6482
6483
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6484
5
{
6485
5
  USE_OPLINE
6486
5
  zval *op1, *op2;
6487
5
  double d1, d2;
6488
6489
5
  op1 = RT_CONSTANT(opline, opline->op1);
6490
5
  op2 = RT_CONSTANT(opline, opline->op2);
6491
5
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6492
    /* pass */
6493
5
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6494
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6495
0
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
6496
0
is_smaller_true:
6497
0
        ZEND_VM_SMART_BRANCH_TRUE();
6498
0
      } else {
6499
0
is_smaller_false:
6500
0
        ZEND_VM_SMART_BRANCH_FALSE();
6501
0
      }
6502
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6503
0
      d1 = (double)Z_LVAL_P(op1);
6504
0
      d2 = Z_DVAL_P(op2);
6505
0
      goto is_smaller_double;
6506
0
    }
6507
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6508
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6509
0
      d1 = Z_DVAL_P(op1);
6510
0
      d2 = Z_DVAL_P(op2);
6511
0
is_smaller_double:
6512
0
      if (d1 < d2) {
6513
0
        goto is_smaller_true;
6514
0
      } else {
6515
0
        goto is_smaller_false;
6516
0
      }
6517
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6518
0
      d1 = Z_DVAL_P(op1);
6519
0
      d2 = (double)Z_LVAL_P(op2);
6520
0
      goto is_smaller_double;
6521
0
    }
6522
0
  }
6523
5
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6524
5
}
6525
6526
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6527
0
{
6528
0
  USE_OPLINE
6529
0
  zval *op1, *op2;
6530
0
  double d1, d2;
6531
6532
0
  op1 = RT_CONSTANT(opline, opline->op1);
6533
0
  op2 = RT_CONSTANT(opline, opline->op2);
6534
0
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6535
    /* pass */
6536
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6537
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6538
0
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
6539
0
is_smaller_or_equal_true:
6540
0
        ZEND_VM_SMART_BRANCH_TRUE();
6541
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
6542
0
        ZEND_VM_NEXT_OPCODE();
6543
0
      } else {
6544
0
is_smaller_or_equal_false:
6545
0
        ZEND_VM_SMART_BRANCH_FALSE();
6546
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
6547
0
        ZEND_VM_NEXT_OPCODE();
6548
0
      }
6549
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6550
0
      d1 = (double)Z_LVAL_P(op1);
6551
0
      d2 = Z_DVAL_P(op2);
6552
0
      goto is_smaller_or_equal_double;
6553
0
    }
6554
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6555
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6556
0
      d1 = Z_DVAL_P(op1);
6557
0
      d2 = Z_DVAL_P(op2);
6558
0
is_smaller_or_equal_double:
6559
0
      if (d1 <= d2) {
6560
0
        goto is_smaller_or_equal_true;
6561
0
      } else {
6562
0
        goto is_smaller_or_equal_false;
6563
0
      }
6564
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6565
0
      d1 = Z_DVAL_P(op1);
6566
0
      d2 = (double)Z_LVAL_P(op2);
6567
0
      goto is_smaller_or_equal_double;
6568
0
    }
6569
0
  }
6570
0
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6571
0
}
6572
6573
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6574
0
{
6575
0
  USE_OPLINE
6576
0
  zval *op1, *op2;
6577
6578
0
  SAVE_OPLINE();
6579
0
  op1 = RT_CONSTANT(opline, opline->op1);
6580
0
  op2 = RT_CONSTANT(opline, opline->op2);
6581
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
6582
6583
6584
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6585
0
}
6586
6587
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6588
1.42k
{
6589
1.42k
  USE_OPLINE
6590
1.42k
  zval *op1, *op2;
6591
6592
1.42k
  op1 = RT_CONSTANT(opline, opline->op1);
6593
1.42k
  op2 = RT_CONSTANT(opline, opline->op2);
6594
1.42k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6595
    /* pass */
6596
1.42k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6597
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6598
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
6599
0
    ZEND_VM_NEXT_OPCODE();
6600
0
  }
6601
6602
1.42k
  ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6603
1.42k
}
6604
6605
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6606
1.54k
{
6607
1.54k
  USE_OPLINE
6608
1.54k
  zval *op1, *op2;
6609
6610
1.54k
  op1 = RT_CONSTANT(opline, opline->op1);
6611
1.54k
  op2 = RT_CONSTANT(opline, opline->op2);
6612
1.54k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6613
    /* pass */
6614
1.54k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6615
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6616
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
6617
0
    ZEND_VM_NEXT_OPCODE();
6618
0
  }
6619
6620
1.54k
  ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6621
1.54k
}
6622
6623
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6624
31.2k
{
6625
31.2k
  USE_OPLINE
6626
31.2k
  zval *op1, *op2;
6627
6628
31.2k
  op1 = RT_CONSTANT(opline, opline->op1);
6629
31.2k
  op2 = RT_CONSTANT(opline, opline->op2);
6630
31.2k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6631
    /* pass */
6632
31.2k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6633
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6634
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
6635
0
    ZEND_VM_NEXT_OPCODE();
6636
0
  }
6637
6638
31.2k
  ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6639
31.2k
}
6640
6641
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6642
0
{
6643
0
  USE_OPLINE
6644
0
  zval *op1, *op2;
6645
6646
0
  SAVE_OPLINE();
6647
0
  op1 = RT_CONSTANT(opline, opline->op1);
6648
0
  op2 = RT_CONSTANT(opline, opline->op2);
6649
0
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
6650
6651
6652
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6653
0
}
6654
6655
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6656
557
{
6657
557
  USE_OPLINE
6658
557
  zval *container, *dim, *value;
6659
6660
557
  SAVE_OPLINE();
6661
557
  container = RT_CONSTANT(opline, opline->op1);
6662
557
  dim = RT_CONSTANT(opline, opline->op2);
6663
557
  if (IS_CONST != IS_CONST) {
6664
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6665
0
fetch_dim_r_array:
6666
0
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
6667
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
6668
0
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
6669
0
      container = Z_REFVAL_P(container);
6670
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6671
0
        goto fetch_dim_r_array;
6672
0
      } else {
6673
0
        goto fetch_dim_r_slow;
6674
0
      }
6675
0
    } else {
6676
0
fetch_dim_r_slow:
6677
0
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
6678
0
        dim++;
6679
0
      }
6680
0
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
6681
0
    }
6682
557
  } else {
6683
557
    zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6684
557
  }
6685
6686
6687
557
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6688
557
}
6689
6690
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6691
0
{
6692
0
  USE_OPLINE
6693
0
  zval *container;
6694
6695
0
  SAVE_OPLINE();
6696
0
  container = RT_CONSTANT(opline, opline->op1);
6697
0
  zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6698
6699
6700
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6701
0
}
6702
6703
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6704
16
{
6705
#if 0
6706
  USE_OPLINE
6707
#endif
6708
6709
16
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
6710
5
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
6711
5
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6712
5
    }
6713
5
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6714
11
  } else {
6715
11
    if (IS_CONST == IS_UNUSED) {
6716
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6717
0
    }
6718
11
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6719
11
  }
6720
16
}
6721
6722
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6723
53
{
6724
53
  USE_OPLINE
6725
53
  zval *container;
6726
53
  void **cache_slot = NULL;
6727
6728
53
  SAVE_OPLINE();
6729
53
  container = RT_CONSTANT(opline, opline->op1);
6730
6731
53
  if (IS_CONST == IS_CONST ||
6732
53
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6733
53
    do {
6734
53
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6735
0
        container = Z_REFVAL_P(container);
6736
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6737
0
          break;
6738
0
        }
6739
0
      }
6740
53
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
6741
0
        ZVAL_UNDEFINED_OP1();
6742
0
      }
6743
53
      zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
6744
53
      ZVAL_NULL(EX_VAR(opline->result.var));
6745
53
      goto fetch_obj_r_finish;
6746
53
    } while (0);
6747
53
  }
6748
6749
  /* here we are sure we are dealing with an object */
6750
0
  do {
6751
0
    zend_object *zobj = Z_OBJ_P(container);
6752
0
    zend_string *name, *tmp_name;
6753
0
    zval *retval;
6754
6755
0
    if (IS_CONST == IS_CONST) {
6756
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
6757
6758
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6759
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6760
6761
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6762
0
fetch_obj_r_simple:
6763
0
          retval = OBJ_PROP(zobj, prop_offset);
6764
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
6765
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6766
0
              goto fetch_obj_r_copy;
6767
0
            } else {
6768
0
fetch_obj_r_fast_copy:
6769
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6770
0
              ZEND_VM_NEXT_OPCODE();
6771
0
            }
6772
0
          }
6773
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
6774
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
6775
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
6776
0
            prop_offset = prop_info->offset;
6777
0
            goto fetch_obj_r_simple;
6778
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
6779
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
6780
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
6781
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
6782
6783
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
6784
0
            if (IS_CONST & IS_CV) {
6785
0
              GC_ADDREF(zobj);
6786
0
            }
6787
0
            if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
6788
0
              call_info |= ZEND_CALL_RELEASE_THIS;
6789
0
            }
6790
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
6791
0
            call->prev_execute_data = execute_data;
6792
0
            call->call = NULL;
6793
0
            call->return_value = EX_VAR(opline->result.var);
6794
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
6795
6796
0
            execute_data = call;
6797
0
            EG(current_execute_data) = execute_data;
6798
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
6799
6800
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
6801
            opline = hook->op_array.opcodes;
6802
#else
6803
0
            EX(opline) = hook->op_array.opcodes;
6804
0
#endif
6805
0
            LOAD_OPLINE_EX();
6806
6807
6808
0
            ZEND_VM_ENTER_EX();
6809
0
          }
6810
          /* Fall through to read_property for hooks. */
6811
0
        } else if (EXPECTED(zobj->properties != NULL)) {
6812
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
6813
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6814
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6815
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6816
6817
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6818
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6819
6820
0
              if (EXPECTED(p->key == name) ||
6821
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
6822
0
                   EXPECTED(p->key != NULL) &&
6823
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
6824
0
                retval = &p->val;
6825
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6826
0
                  goto fetch_obj_r_copy;
6827
0
                } else {
6828
0
                  goto fetch_obj_r_fast_copy;
6829
0
                }
6830
0
              }
6831
0
            }
6832
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6833
0
          }
6834
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
6835
0
          if (EXPECTED(retval)) {
6836
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6837
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6838
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6839
0
              goto fetch_obj_r_copy;
6840
0
            } else {
6841
0
              goto fetch_obj_r_fast_copy;
6842
0
            }
6843
0
          }
6844
0
        }
6845
0
      }
6846
0
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6847
0
    } else {
6848
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6849
0
      if (UNEXPECTED(!name)) {
6850
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
6851
0
        break;
6852
0
      }
6853
0
    }
6854
6855
0
#if ZEND_DEBUG
6856
    /* For non-standard object handlers, verify a declared property type in debug builds.
6857
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
6858
0
    zend_property_info *prop_info = NULL;
6859
0
    if (zobj->handlers->read_property != zend_std_read_property) {
6860
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
6861
0
    }
6862
0
#endif
6863
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
6864
0
#if ZEND_DEBUG
6865
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
6866
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
6867
0
      ZVAL_OPT_DEREF(retval);
6868
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
6869
0
    }
6870
0
#endif
6871
6872
0
    if (IS_CONST != IS_CONST) {
6873
0
      zend_tmp_string_release(tmp_name);
6874
0
    }
6875
6876
0
    if (retval != EX_VAR(opline->result.var)) {
6877
0
fetch_obj_r_copy:
6878
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6879
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
6880
0
      zend_unwrap_reference(retval);
6881
0
    }
6882
0
  } while (0);
6883
6884
53
fetch_obj_r_finish:
6885
6886
6887
53
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6888
53
}
6889
6890
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6891
5
{
6892
5
  USE_OPLINE
6893
5
  zval *container;
6894
5
  void **cache_slot = NULL;
6895
6896
5
  SAVE_OPLINE();
6897
5
  container = RT_CONSTANT(opline, opline->op1);
6898
6899
5
  if (IS_CONST == IS_CONST ||
6900
5
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6901
5
    do {
6902
5
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6903
0
        container = Z_REFVAL_P(container);
6904
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6905
0
          break;
6906
0
        }
6907
0
      }
6908
5
      if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
6909
0
        ZVAL_UNDEFINED_OP2();
6910
0
      }
6911
5
      ZVAL_NULL(EX_VAR(opline->result.var));
6912
5
      goto fetch_obj_is_finish;
6913
5
    } while (0);
6914
5
  }
6915
6916
  /* here we are sure we are dealing with an object */
6917
0
  do {
6918
0
    zend_object *zobj = Z_OBJ_P(container);
6919
0
    zend_string *name, *tmp_name;
6920
0
    zval *retval;
6921
6922
0
    if (IS_CONST == IS_CONST) {
6923
0
      cache_slot = CACHE_ADDR(opline->extended_value);
6924
6925
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6926
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6927
6928
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6929
0
fetch_obj_is_simple:
6930
0
          retval = OBJ_PROP(zobj, prop_offset);
6931
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
6932
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6933
0
              goto fetch_obj_is_copy;
6934
0
            } else {
6935
0
fetch_obj_is_fast_copy:
6936
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6937
0
              ZEND_VM_NEXT_OPCODE();
6938
0
            }
6939
0
          }
6940
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
6941
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
6942
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
6943
0
            prop_offset = prop_info->offset;
6944
0
            goto fetch_obj_is_simple;
6945
0
          }
6946
          /* Fall through to read_property for hooks. */
6947
0
        } else if (EXPECTED(zobj->properties != NULL)) {
6948
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
6949
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6950
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6951
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6952
6953
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6954
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6955
6956
0
              if (EXPECTED(p->key == name) ||
6957
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
6958
0
                   EXPECTED(p->key != NULL) &&
6959
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
6960
0
                retval = &p->val;
6961
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6962
0
                  goto fetch_obj_is_copy;
6963
0
                } else {
6964
0
                  goto fetch_obj_is_fast_copy;
6965
0
                }
6966
0
              }
6967
0
            }
6968
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6969
0
          }
6970
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
6971
0
          if (EXPECTED(retval)) {
6972
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6973
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6974
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6975
0
              goto fetch_obj_is_copy;
6976
0
            } else {
6977
0
              goto fetch_obj_is_fast_copy;
6978
0
            }
6979
0
          }
6980
0
        }
6981
0
      }
6982
0
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6983
0
    } else {
6984
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6985
0
      if (UNEXPECTED(!name)) {
6986
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
6987
0
        break;
6988
0
      }
6989
0
    }
6990
6991
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
6992
6993
0
    if (IS_CONST != IS_CONST) {
6994
0
      zend_tmp_string_release(tmp_name);
6995
0
    }
6996
6997
0
    if (retval != EX_VAR(opline->result.var)) {
6998
0
fetch_obj_is_copy:
6999
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
7000
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
7001
0
      zend_unwrap_reference(retval);
7002
0
    }
7003
0
  } while (0);
7004
7005
5
fetch_obj_is_finish:
7006
7007
7008
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7009
5
}
7010
7011
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7012
5
{
7013
#if 0
7014
  USE_OPLINE
7015
#endif
7016
7017
5
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
7018
    /* Behave like FETCH_OBJ_W */
7019
5
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
7020
5
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7021
5
    }
7022
5
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7023
5
  } else {
7024
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7025
0
  }
7026
5
}
7027
7028
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7029
94
{
7030
94
  USE_OPLINE
7031
94
  zval *container;
7032
7033
94
  SAVE_OPLINE();
7034
94
  container = RT_CONSTANT(opline, opline->op1);
7035
94
  zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
7036
7037
94
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7038
94
}
7039
7040
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7041
186
{
7042
186
  USE_OPLINE
7043
186
  zval *op1, *op2;
7044
186
  zend_string *op1_str, *op2_str, *str;
7045
7046
7047
186
  op1 = RT_CONSTANT(opline, opline->op1);
7048
186
  op2 = RT_CONSTANT(opline, opline->op2);
7049
186
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
7050
186
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
7051
186
    zend_string *op1_str = Z_STR_P(op1);
7052
186
    zend_string *op2_str = Z_STR_P(op2);
7053
186
    zend_string *str;
7054
186
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
7055
7056
186
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
7057
0
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
7058
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
7059
0
      } else {
7060
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
7061
0
      }
7062
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7063
0
        zend_string_release_ex(op1_str, 0);
7064
0
      }
7065
186
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
7066
0
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
7067
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
7068
0
      } else {
7069
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
7070
0
      }
7071
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7072
0
        zend_string_release_ex(op2_str, 0);
7073
0
      }
7074
186
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
7075
186
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
7076
0
      size_t len = ZSTR_LEN(op1_str);
7077
7078
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
7079
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7080
0
      GC_ADD_FLAGS(str, flags);
7081
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7082
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7083
0
        zend_string_release_ex(op2_str, 0);
7084
0
      }
7085
186
    } else {
7086
186
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
7087
186
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
7088
186
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7089
186
      GC_ADD_FLAGS(str, flags);
7090
186
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7091
186
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7092
0
        zend_string_release_ex(op1_str, 0);
7093
0
      }
7094
186
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7095
0
        zend_string_release_ex(op2_str, 0);
7096
0
      }
7097
186
    }
7098
186
    ZEND_VM_NEXT_OPCODE();
7099
186
  }
7100
7101
186
  SAVE_OPLINE();
7102
0
  if (IS_CONST == IS_CONST) {
7103
0
    op1_str = Z_STR_P(op1);
7104
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
7105
0
    op1_str = zend_string_copy(Z_STR_P(op1));
7106
0
  } else {
7107
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
7108
0
      ZVAL_UNDEFINED_OP1();
7109
0
    }
7110
0
    op1_str = zval_get_string_func(op1);
7111
0
  }
7112
0
  if (IS_CONST == IS_CONST) {
7113
0
    op2_str = Z_STR_P(op2);
7114
0
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
7115
0
    op2_str = zend_string_copy(Z_STR_P(op2));
7116
0
  } else {
7117
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
7118
0
      ZVAL_UNDEFINED_OP2();
7119
0
    }
7120
0
    op2_str = zval_get_string_func(op2);
7121
0
  }
7122
0
  do {
7123
0
    if (IS_CONST != IS_CONST) {
7124
0
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
7125
0
        if (IS_CONST == IS_CONST) {
7126
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
7127
0
            GC_ADDREF(op2_str);
7128
0
          }
7129
0
        }
7130
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
7131
0
        zend_string_release_ex(op1_str, 0);
7132
0
        break;
7133
0
      }
7134
0
    }
7135
0
    if (IS_CONST != IS_CONST) {
7136
0
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
7137
0
        if (IS_CONST == IS_CONST) {
7138
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
7139
0
            GC_ADDREF(op1_str);
7140
0
          }
7141
0
        }
7142
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
7143
0
        zend_string_release_ex(op2_str, 0);
7144
0
        break;
7145
0
      }
7146
0
    }
7147
0
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
7148
0
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
7149
0
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7150
7151
0
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
7152
0
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7153
0
    if (IS_CONST != IS_CONST) {
7154
0
      zend_string_release_ex(op1_str, 0);
7155
0
    }
7156
0
    if (IS_CONST != IS_CONST) {
7157
0
      zend_string_release_ex(op2_str, 0);
7158
0
    }
7159
0
  } while (0);
7160
7161
7162
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7163
0
}
7164
7165
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7166
73
{
7167
73
  USE_OPLINE
7168
73
  zval *function_name;
7169
73
  zval *object;
7170
73
  zend_function *fbc;
7171
73
  zend_class_entry *called_scope;
7172
73
  zend_object *obj;
7173
73
  zend_execute_data *call;
7174
73
  uint32_t call_info;
7175
7176
73
  SAVE_OPLINE();
7177
7178
73
  object = RT_CONSTANT(opline, opline->op1);
7179
7180
73
  if (IS_CONST != IS_CONST) {
7181
0
    function_name = RT_CONSTANT(opline, opline->op2);
7182
0
  }
7183
7184
73
  if (IS_CONST != IS_CONST &&
7185
73
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7186
0
    do {
7187
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
7188
0
        function_name = Z_REFVAL_P(function_name);
7189
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
7190
0
          break;
7191
0
        }
7192
0
      } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
7193
0
        ZVAL_UNDEFINED_OP2();
7194
0
        if (UNEXPECTED(EG(exception) != NULL)) {
7195
7196
0
          HANDLE_EXCEPTION();
7197
0
        }
7198
0
      }
7199
0
      zend_throw_error(NULL, "Method name must be a string");
7200
7201
7202
0
      HANDLE_EXCEPTION();
7203
0
    } while (0);
7204
0
  }
7205
7206
73
  if (IS_CONST == IS_UNUSED) {
7207
0
    obj = Z_OBJ_P(object);
7208
73
  } else {
7209
73
    do {
7210
73
      if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
7211
0
        obj = Z_OBJ_P(object);
7212
73
      } else {
7213
73
        if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
7214
0
          zend_reference *ref = Z_REF_P(object);
7215
7216
0
          object = &ref->val;
7217
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
7218
0
            obj = Z_OBJ_P(object);
7219
0
            if (IS_CONST & IS_VAR) {
7220
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7221
0
                efree_size(ref, sizeof(zend_reference));
7222
0
              } else {
7223
0
                Z_ADDREF_P(object);
7224
0
              }
7225
0
            }
7226
0
            break;
7227
0
          }
7228
0
        }
7229
73
        if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
7230
0
          object = ZVAL_UNDEFINED_OP1();
7231
0
          if (UNEXPECTED(EG(exception) != NULL)) {
7232
0
            if (IS_CONST != IS_CONST) {
7233
7234
0
            }
7235
0
            HANDLE_EXCEPTION();
7236
0
          }
7237
0
        }
7238
73
        if (IS_CONST == IS_CONST) {
7239
73
          function_name = RT_CONSTANT(opline, opline->op2);
7240
73
        }
7241
73
        zend_invalid_method_call(object, function_name);
7242
7243
7244
73
        HANDLE_EXCEPTION();
7245
73
      }
7246
73
    } while (0);
7247
73
  }
7248
7249
0
  called_scope = obj->ce;
7250
7251
0
  if (IS_CONST == IS_CONST &&
7252
0
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
7253
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
7254
0
  } else {
7255
0
    zend_object *orig_obj = obj;
7256
7257
0
    if (IS_CONST == IS_CONST) {
7258
0
      function_name = RT_CONSTANT(opline, opline->op2);
7259
0
    }
7260
7261
    /* First, locate the function. */
7262
0
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
7263
0
    if (UNEXPECTED(fbc == NULL)) {
7264
0
      if (EXPECTED(!EG(exception))) {
7265
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
7266
0
      }
7267
7268
0
      if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
7269
0
        zend_objects_store_del(orig_obj);
7270
0
      }
7271
0
      HANDLE_EXCEPTION();
7272
0
    }
7273
0
    if (IS_CONST == IS_CONST &&
7274
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7275
0
        EXPECTED(obj == orig_obj)) {
7276
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
7277
0
    }
7278
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
7279
0
      GC_ADDREF(obj); /* For $this pointer */
7280
0
      if (GC_DELREF(orig_obj) == 0) {
7281
0
        zend_objects_store_del(orig_obj);
7282
0
      }
7283
0
    }
7284
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7285
0
      init_func_run_time_cache(&fbc->op_array);
7286
0
    }
7287
0
  }
7288
7289
0
  if (IS_CONST != IS_CONST) {
7290
7291
0
  }
7292
7293
0
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7294
0
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
7295
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
7296
0
      zend_objects_store_del(obj);
7297
0
      if (UNEXPECTED(EG(exception))) {
7298
0
        HANDLE_EXCEPTION();
7299
0
      }
7300
0
    }
7301
    /* call static method */
7302
0
    obj = (zend_object*)called_scope;
7303
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
7304
0
  } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
7305
0
    if (IS_CONST == IS_CV) {
7306
0
      GC_ADDREF(obj); /* For $this pointer */
7307
0
    }
7308
    /* CV may be changed indirectly (e.g. when it's a reference) */
7309
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
7310
0
  }
7311
7312
0
  call = zend_vm_stack_push_call_frame(call_info,
7313
0
    fbc, opline->extended_value, obj);
7314
0
  call->prev_execute_data = EX(call);
7315
0
  EX(call) = call;
7316
7317
0
  ZEND_VM_NEXT_OPCODE();
7318
0
}
7319
7320
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7321
5.82k
{
7322
5.82k
  USE_OPLINE
7323
5.82k
  zval *function_name;
7324
5.82k
  zend_class_entry *ce;
7325
5.82k
  uint32_t call_info;
7326
5.82k
  zend_function *fbc;
7327
5.82k
  zend_execute_data *call;
7328
7329
5.82k
  SAVE_OPLINE();
7330
7331
5.82k
  if (IS_CONST == IS_CONST) {
7332
    /* no function found. try a static method in class */
7333
5.82k
    ce = CACHED_PTR(opline->result.num);
7334
5.82k
    if (UNEXPECTED(ce == NULL)) {
7335
4.01k
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
7336
4.01k
      if (UNEXPECTED(ce == NULL)) {
7337
7338
90
        HANDLE_EXCEPTION();
7339
90
      }
7340
3.92k
      if (IS_CONST != IS_CONST) {
7341
0
        CACHE_PTR(opline->result.num, ce);
7342
0
      }
7343
3.92k
    }
7344
5.82k
  } else if (IS_CONST == IS_UNUSED) {
7345
0
    ce = zend_fetch_class(NULL, opline->op1.num);
7346
0
    if (UNEXPECTED(ce == NULL)) {
7347
7348
0
      HANDLE_EXCEPTION();
7349
0
    }
7350
0
  } else {
7351
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
7352
0
  }
7353
7354
5.73k
  if (IS_CONST == IS_CONST &&
7355
5.73k
      IS_CONST == IS_CONST &&
7356
5.73k
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
7357
    /* nothing to do */
7358
3.92k
  } else if (IS_CONST != IS_CONST &&
7359
3.92k
             IS_CONST == IS_CONST &&
7360
3.92k
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
7361
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
7362
3.92k
  } else if (IS_CONST != IS_UNUSED) {
7363
3.92k
    function_name = RT_CONSTANT(opline, opline->op2);
7364
3.92k
    if (IS_CONST != IS_CONST) {
7365
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7366
0
        do {
7367
0
          if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
7368
0
            function_name = Z_REFVAL_P(function_name);
7369
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
7370
0
              break;
7371
0
            }
7372
0
          } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
7373
0
            ZVAL_UNDEFINED_OP2();
7374
0
            if (UNEXPECTED(EG(exception) != NULL)) {
7375
0
              HANDLE_EXCEPTION();
7376
0
            }
7377
0
          }
7378
0
          zend_throw_error(NULL, "Method name must be a string");
7379
7380
0
          HANDLE_EXCEPTION();
7381
0
        } while (0);
7382
0
      }
7383
0
    }
7384
7385
3.92k
    if (ce->get_static_method) {
7386
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
7387
3.92k
    } else {
7388
3.92k
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
7389
3.92k
    }
7390
3.92k
    if (UNEXPECTED(fbc == NULL)) {
7391
141
      if (EXPECTED(!EG(exception))) {
7392
73
        zend_undefined_method(ce, Z_STR_P(function_name));
7393
73
      }
7394
7395
141
      HANDLE_EXCEPTION();
7396
141
    }
7397
3.78k
    if (IS_CONST == IS_CONST &&
7398
3.78k
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7399
3.78k
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
7400
3.34k
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
7401
3.34k
    }
7402
3.78k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7403
1.95k
      init_func_run_time_cache(&fbc->op_array);
7404
1.95k
    }
7405
3.78k
    if (IS_CONST != IS_CONST) {
7406
7407
0
    }
7408
3.78k
  } else {
7409
5
    if (UNEXPECTED(ce->constructor == NULL)) {
7410
0
      zend_throw_error(NULL, "Cannot call constructor");
7411
0
      HANDLE_EXCEPTION();
7412
0
    }
7413
5
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
7414
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
7415
0
      HANDLE_EXCEPTION();
7416
0
    }
7417
5
    fbc = ce->constructor;
7418
5
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7419
0
      init_func_run_time_cache(&fbc->op_array);
7420
0
    }
7421
5
  }
7422
7423
5.59k
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
7424
228
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
7425
213
      ce = (zend_class_entry*)Z_OBJ(EX(This));
7426
213
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7427
213
    } else {
7428
15
      zend_non_static_method_call(fbc);
7429
15
      HANDLE_EXCEPTION();
7430
15
    }
7431
5.36k
  } else {
7432
    /* previous opcode is ZEND_FETCH_CLASS */
7433
5.36k
    if (IS_CONST == IS_UNUSED
7434
5.36k
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
7435
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
7436
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
7437
0
        ce = Z_OBJCE(EX(This));
7438
0
      } else {
7439
0
        ce = Z_CE(EX(This));
7440
0
      }
7441
0
    }
7442
5.36k
    call_info = ZEND_CALL_NESTED_FUNCTION;
7443
5.36k
  }
7444
7445
5.57k
  call = zend_vm_stack_push_call_frame(call_info,
7446
5.57k
    fbc, opline->extended_value, ce);
7447
5.57k
  call->prev_execute_data = EX(call);
7448
5.57k
  EX(call) = call;
7449
7450
5.57k
  ZEND_VM_NEXT_OPCODE();
7451
5.57k
}
7452
7453
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7454
365
{
7455
365
  USE_OPLINE
7456
365
  zval *function_name;
7457
365
  zend_fcall_info_cache fcc;
7458
365
  char *error = NULL;
7459
365
  zend_function *func;
7460
365
  void *object_or_called_scope;
7461
365
  zend_execute_data *call;
7462
365
  uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
7463
7464
365
  SAVE_OPLINE();
7465
365
  function_name = RT_CONSTANT(opline, opline->op2);
7466
365
  if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
7467
317
    ZEND_ASSERT(!error);
7468
7469
    /* Deprecation can be emitted from zend_is_callable_ex(), which can
7470
     * invoke a user error handler and throw an exception.
7471
     * For the CONST and CV case we reuse the same exception block below
7472
     * to make sure we don't increase VM size too much. */
7473
317
    if (!(IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7474
7475
5
      HANDLE_EXCEPTION();
7476
5
    }
7477
7478
312
    func = fcc.function_handler;
7479
312
    object_or_called_scope = fcc.called_scope;
7480
312
    if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
7481
      /* Delay closure destruction until its invocation */
7482
0
      GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
7483
0
      call_info |= ZEND_CALL_CLOSURE;
7484
0
      if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
7485
0
        call_info |= ZEND_CALL_FAKE_CLOSURE;
7486
0
      }
7487
0
      if (fcc.object) {
7488
0
        object_or_called_scope = fcc.object;
7489
0
        call_info |= ZEND_CALL_HAS_THIS;
7490
0
      }
7491
312
    } else if (fcc.object) {
7492
73
      GC_ADDREF(fcc.object); /* For $this pointer */
7493
73
      object_or_called_scope = fcc.object;
7494
73
      call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
7495
73
    }
7496
7497
312
    if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7498
0
      if (call_info & ZEND_CALL_CLOSURE) {
7499
0
        zend_object_release(ZEND_CLOSURE_OBJECT(func));
7500
0
      } else if (call_info & ZEND_CALL_RELEASE_THIS) {
7501
0
        zend_object_release(fcc.object);
7502
0
      }
7503
0
      HANDLE_EXCEPTION();
7504
0
    }
7505
7506
312
    if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
7507
62
      init_func_run_time_cache(&func->op_array);
7508
62
    }
7509
312
  } else {
7510
48
    zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
7511
48
    efree(error);
7512
7513
48
    HANDLE_EXCEPTION();
7514
48
  }
7515
7516
312
  call = zend_vm_stack_push_call_frame(call_info,
7517
312
    func, opline->extended_value, object_or_called_scope);
7518
312
  call->prev_execute_data = EX(call);
7519
312
  EX(call) = call;
7520
7521
312
  ZEND_VM_NEXT_OPCODE();
7522
312
}
7523
7524
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7525
363
{
7526
363
  USE_OPLINE
7527
363
  zval *value, *arg;
7528
7529
363
  if (IS_CONST == IS_CONST) {
7530
363
    SAVE_OPLINE();
7531
363
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7532
363
    uint32_t arg_num;
7533
363
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7534
363
    if (UNEXPECTED(!arg)) {
7535
7536
24
      HANDLE_EXCEPTION();
7537
24
    }
7538
363
  } else {
7539
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7540
0
  }
7541
7542
339
  value = RT_CONSTANT(opline, opline->op1);
7543
339
  ZVAL_COPY_VALUE(arg, value);
7544
339
  if (IS_CONST == IS_CONST) {
7545
339
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7546
0
      Z_ADDREF_P(arg);
7547
0
    }
7548
339
  }
7549
339
  ZEND_VM_NEXT_OPCODE();
7550
339
}
7551
7552
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7553
878
{
7554
878
  USE_OPLINE
7555
878
  zval *value, *arg;
7556
878
  uint32_t arg_num;
7557
7558
878
  if (IS_CONST == IS_CONST) {
7559
878
    SAVE_OPLINE();
7560
878
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7561
878
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7562
878
    if (UNEXPECTED(!arg)) {
7563
7564
61
      HANDLE_EXCEPTION();
7565
61
    }
7566
878
  } else {
7567
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7568
0
    arg_num = opline->op2.num;
7569
0
  }
7570
7571
817
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
7572
817
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7573
5
      goto send_val_by_ref;
7574
5
    }
7575
817
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7576
5
send_val_by_ref:
7577
5
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
7578
0
  }
7579
812
  value = RT_CONSTANT(opline, opline->op1);
7580
812
  ZVAL_COPY_VALUE(arg, value);
7581
812
  if (IS_CONST == IS_CONST) {
7582
812
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7583
0
      Z_ADDREF_P(arg);
7584
0
    }
7585
812
  }
7586
812
  ZEND_VM_NEXT_OPCODE();
7587
812
}
7588
7589
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7590
2.57k
{
7591
2.57k
  zend_class_entry *ce, *scope;
7592
2.57k
  zend_class_constant *c;
7593
2.57k
  zval *value, *zv, *constant_zv;
7594
2.57k
  zend_string *constant_name;
7595
2.57k
  USE_OPLINE
7596
7597
2.57k
  SAVE_OPLINE();
7598
7599
2.57k
  do {
7600
2.57k
    if (IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
7601
2.57k
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
7602
569
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
7603
569
        break;
7604
569
      }
7605
2.57k
    }
7606
2.00k
    if (IS_CONST == IS_CONST) {
7607
2.00k
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
7608
61
        ce = CACHED_PTR(opline->extended_value);
7609
1.94k
      } else {
7610
1.94k
        ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
7611
1.94k
        if (UNEXPECTED(ce == NULL)) {
7612
79
          ZVAL_UNDEF(EX_VAR(opline->result.var));
7613
7614
79
          HANDLE_EXCEPTION();
7615
79
        }
7616
1.86k
        CACHE_PTR(opline->extended_value, ce);
7617
1.86k
      }
7618
2.00k
    } else if (IS_CONST == IS_UNUSED) {
7619
0
      ce = zend_fetch_class(NULL, opline->op1.num);
7620
0
      if (UNEXPECTED(ce == NULL)) {
7621
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
7622
7623
0
        HANDLE_EXCEPTION();
7624
0
      }
7625
0
    } else {
7626
0
      ce = Z_CE_P(EX_VAR(opline->op1.var));
7627
0
    }
7628
1.92k
    if (IS_CONST != IS_CONST
7629
1.92k
      && IS_CONST == IS_CONST
7630
1.92k
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
7631
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
7632
0
      break;
7633
0
    }
7634
7635
1.92k
    constant_zv = RT_CONSTANT(opline, opline->op2);
7636
1.92k
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
7637
48
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
7638
48
      ZVAL_UNDEF(EX_VAR(opline->result.var));
7639
7640
48
      HANDLE_EXCEPTION();
7641
48
    }
7642
1.87k
    constant_name = Z_STR_P(constant_zv);
7643
    /* Magic 'class' for constant OP2 is caught at compile-time */
7644
1.87k
    if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
7645
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
7646
7647
0
      ZEND_VM_NEXT_OPCODE();
7648
0
    }
7649
1.87k
    zv = IS_CONST == IS_CONST
7650
1.87k
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
7651
1.87k
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
7652
7653
1.87k
    if (EXPECTED(zv != NULL)) {
7654
1.80k
      c = Z_PTR_P(zv);
7655
1.80k
      scope = EX(func)->op_array.scope;
7656
1.80k
      if (!zend_verify_const_access(c, scope)) {
7657
5
        zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7658
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
7659
7660
5
        HANDLE_EXCEPTION();
7661
5
      }
7662
7663
1.79k
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
7664
5
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7665
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
7666
7667
5
        HANDLE_EXCEPTION();
7668
5
      }
7669
7670
1.79k
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
7671
1.79k
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
7672
64
        if (c->ce->type == ZEND_USER_CLASS) {
7673
          /* Recursion protection only applied to user constants, GH-18463 */
7674
64
          CONST_PROTECT_RECURSION(c);
7675
64
        }
7676
64
        zend_deprecated_class_constant(c, constant_name);
7677
64
        if (c->ce->type == ZEND_USER_CLASS) {
7678
64
          CONST_UNPROTECT_RECURSION(c);
7679
64
        }
7680
7681
64
        if (EG(exception)) {
7682
12
          ZVAL_UNDEF(EX_VAR(opline->result.var));
7683
7684
12
          HANDLE_EXCEPTION();
7685
12
        }
7686
64
      }
7687
7688
1.78k
      value = &c->value;
7689
      // Enums require loading of all class constants to build the backed enum table
7690
1.78k
      if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
7691
290
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
7692
68
          ZVAL_UNDEF(EX_VAR(opline->result.var));
7693
7694
68
          HANDLE_EXCEPTION();
7695
68
        }
7696
290
      }
7697
1.71k
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
7698
1.15k
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
7699
112
          ZVAL_UNDEF(EX_VAR(opline->result.var));
7700
7701
112
          HANDLE_EXCEPTION();
7702
112
        }
7703
1.15k
      }
7704
1.60k
      if (IS_CONST == IS_CONST && !is_constant_deprecated) {
7705
1.54k
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
7706
1.54k
      }
7707
1.60k
    } else {
7708
72
      zend_throw_error(NULL, "Undefined constant %s::%s",
7709
72
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7710
72
      ZVAL_UNDEF(EX_VAR(opline->result.var));
7711
7712
72
      HANDLE_EXCEPTION();
7713
72
    }
7714
1.87k
  } while (0);
7715
7716
2.17k
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
7717
7718
2.17k
  ZEND_VM_NEXT_OPCODE();
7719
2.17k
}
7720
7721
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7722
452
{
7723
452
  USE_OPLINE
7724
452
  zval *expr_ptr, new_expr;
7725
7726
452
  SAVE_OPLINE();
7727
452
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
7728
452
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
7729
0
    expr_ptr = zend_get_bad_ptr();
7730
0
    if (Z_ISREF_P(expr_ptr)) {
7731
0
      Z_ADDREF_P(expr_ptr);
7732
0
    } else {
7733
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
7734
0
    }
7735
7736
452
  } else {
7737
452
    expr_ptr = RT_CONSTANT(opline, opline->op1);
7738
452
    if (IS_CONST == IS_TMP_VAR) {
7739
      /* pass */
7740
452
    } else if (IS_CONST == IS_CONST) {
7741
452
      Z_TRY_ADDREF_P(expr_ptr);
7742
452
    } else if (IS_CONST == IS_CV) {
7743
0
      ZVAL_DEREF(expr_ptr);
7744
0
      Z_TRY_ADDREF_P(expr_ptr);
7745
0
    } else /* if (IS_CONST == IS_VAR) */ {
7746
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
7747
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
7748
7749
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
7750
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7751
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
7752
0
          expr_ptr = &new_expr;
7753
0
          efree_size(ref, sizeof(zend_reference));
7754
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
7755
0
          Z_ADDREF_P(expr_ptr);
7756
0
        }
7757
0
      }
7758
0
    }
7759
452
  }
7760
7761
452
  if (IS_CONST != IS_UNUSED) {
7762
452
    zval *offset = RT_CONSTANT(opline, opline->op2);
7763
452
    zend_string *str;
7764
452
    zend_ulong hval;
7765
7766
452
add_again:
7767
452
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7768
389
      str = Z_STR_P(offset);
7769
389
      if (IS_CONST != IS_CONST) {
7770
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
7771
0
          goto num_index;
7772
0
        }
7773
0
      }
7774
389
str_index:
7775
389
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
7776
389
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7777
35
      hval = Z_LVAL_P(offset);
7778
63
num_index:
7779
63
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
7780
63
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
7781
0
      offset = Z_REFVAL_P(offset);
7782
0
      goto add_again;
7783
28
    } else if (Z_TYPE_P(offset) == IS_NULL) {
7784
0
      str = ZSTR_EMPTY_ALLOC();
7785
0
      goto str_index;
7786
28
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
7787
21
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
7788
21
      goto num_index;
7789
21
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
7790
7
      hval = 0;
7791
7
      goto num_index;
7792
7
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
7793
0
      hval = 1;
7794
0
      goto num_index;
7795
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
7796
0
      zend_use_resource_as_offset(offset);
7797
0
      hval = Z_RES_HANDLE_P(offset);
7798
0
      goto num_index;
7799
0
    } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
7800
0
      ZVAL_UNDEFINED_OP2();
7801
0
      str = ZSTR_EMPTY_ALLOC();
7802
0
      goto str_index;
7803
0
    } else {
7804
0
      zend_illegal_array_offset_access(offset);
7805
0
      zval_ptr_dtor_nogc(expr_ptr);
7806
0
    }
7807
7808
452
  } else {
7809
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
7810
0
      zend_cannot_add_element();
7811
0
      zval_ptr_dtor_nogc(expr_ptr);
7812
0
    }
7813
0
  }
7814
452
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7815
452
}
7816
7817
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7818
88
{
7819
88
  zval *array;
7820
88
  uint32_t size;
7821
88
  USE_OPLINE
7822
7823
88
  SAVE_OPLINE();
7824
88
  array = EX_VAR(opline->result.var);
7825
88
  if (IS_CONST != IS_UNUSED) {
7826
88
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
7827
88
    ZVAL_ARR(array, zend_new_array(size));
7828
    /* Explicitly initialize array as not-packed if flag is set */
7829
88
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
7830
45
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
7831
45
    }
7832
88
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7833
88
  } else {
7834
0
    ZVAL_ARR(array, zend_new_array(0));
7835
0
    ZEND_VM_NEXT_OPCODE();
7836
0
  }
7837
88
}
7838
7839
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7840
2
{
7841
2
  USE_OPLINE
7842
2
  zval *container;
7843
2
  bool result;
7844
2
  zend_ulong hval;
7845
2
  zval *offset;
7846
7847
2
  SAVE_OPLINE();
7848
2
  container = RT_CONSTANT(opline, opline->op1);
7849
2
  offset = RT_CONSTANT(opline, opline->op2);
7850
7851
2
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7852
0
    HashTable *ht;
7853
0
    zval *value;
7854
0
    zend_string *str;
7855
7856
0
isset_dim_obj_array:
7857
0
    ht = Z_ARRVAL_P(container);
7858
0
isset_again:
7859
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7860
0
      str = Z_STR_P(offset);
7861
0
      if (IS_CONST != IS_CONST) {
7862
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
7863
0
          goto num_index_prop;
7864
0
        }
7865
0
      }
7866
0
      value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
7867
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7868
0
      hval = Z_LVAL_P(offset);
7869
0
num_index_prop:
7870
0
      value = zend_hash_index_find(ht, hval);
7871
0
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
7872
0
      offset = Z_REFVAL_P(offset);
7873
0
      goto isset_again;
7874
0
    } else {
7875
0
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
7876
0
      if (UNEXPECTED(EG(exception))) {
7877
0
        result = 0;
7878
0
        goto isset_dim_obj_exit;
7879
0
      }
7880
0
    }
7881
7882
0
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
7883
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
7884
0
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
7885
0
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
7886
7887
0
      if (IS_CONST & (IS_CONST|IS_CV)) {
7888
        /* avoid exception check */
7889
7890
0
        ZEND_VM_SMART_BRANCH(result, 0);
7891
0
      }
7892
0
    } else {
7893
0
      result = (value == NULL || !i_zend_is_true(value));
7894
0
    }
7895
0
    goto isset_dim_obj_exit;
7896
2
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
7897
0
    container = Z_REFVAL_P(container);
7898
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7899
0
      goto isset_dim_obj_array;
7900
0
    }
7901
0
  }
7902
7903
2
  if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
7904
0
    offset++;
7905
0
  }
7906
2
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
7907
2
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
7908
2
  } else {
7909
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
7910
0
  }
7911
7912
2
isset_dim_obj_exit:
7913
7914
7915
2
  ZEND_VM_SMART_BRANCH(result, 1);
7916
2
}
7917
7918
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7919
5
{
7920
5
  USE_OPLINE
7921
5
  zval *container;
7922
5
  int result;
7923
5
  zval *offset;
7924
5
  zend_string *name, *tmp_name;
7925
7926
5
  SAVE_OPLINE();
7927
5
  container = RT_CONSTANT(opline, opline->op1);
7928
5
  offset = RT_CONSTANT(opline, opline->op2);
7929
7930
5
  if (IS_CONST == IS_CONST ||
7931
5
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
7932
5
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
7933
0
      container = Z_REFVAL_P(container);
7934
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
7935
0
        result = (opline->extended_value & ZEND_ISEMPTY);
7936
0
        goto isset_object_finish;
7937
0
      }
7938
5
    } else {
7939
5
      result = (opline->extended_value & ZEND_ISEMPTY);
7940
5
      goto isset_object_finish;
7941
5
    }
7942
5
  }
7943
7944
0
  if (IS_CONST == IS_CONST) {
7945
0
    name = Z_STR_P(offset);
7946
0
  } else {
7947
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
7948
0
    if (UNEXPECTED(!name)) {
7949
0
      result = 0;
7950
0
      goto isset_object_finish;
7951
0
    }
7952
0
  }
7953
7954
0
  result =
7955
0
    (opline->extended_value & ZEND_ISEMPTY) ^
7956
0
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
7957
7958
0
  if (IS_CONST != IS_CONST) {
7959
0
    zend_tmp_string_release(tmp_name);
7960
0
  }
7961
7962
5
isset_object_finish:
7963
7964
7965
5
  ZEND_VM_SMART_BRANCH(result, 1);
7966
5
}
7967
7968
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7969
0
{
7970
0
  USE_OPLINE
7971
7972
0
  zval *key, *subject;
7973
0
  HashTable *ht;
7974
0
  bool result;
7975
7976
0
  SAVE_OPLINE();
7977
7978
0
  key = RT_CONSTANT(opline, opline->op1);
7979
0
  subject = RT_CONSTANT(opline, opline->op2);
7980
7981
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7982
0
array_key_exists_array:
7983
0
    ht = Z_ARRVAL_P(subject);
7984
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
7985
0
  } else {
7986
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
7987
0
      subject = Z_REFVAL_P(subject);
7988
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7989
0
        goto array_key_exists_array;
7990
0
      }
7991
0
    }
7992
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
7993
0
    result = 0;
7994
0
  }
7995
7996
7997
0
  ZEND_VM_SMART_BRANCH(result, 1);
7998
0
}
7999
8000
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8001
668
{
8002
668
  USE_OPLINE
8003
8004
668
  zend_class_entry *ce = CACHED_PTR(opline->extended_value);
8005
668
  if (ce == NULL) {
8006
641
    zval *lcname = RT_CONSTANT(opline, opline->op1);
8007
641
    zval *zv = zend_hash_find_known_hash(EG(class_table), Z_STR_P(lcname + 1));
8008
641
    if (zv) {
8009
641
      SAVE_OPLINE();
8010
641
      ce = zend_bind_class_in_slot(zv, lcname, Z_STR_P(RT_CONSTANT(opline, opline->op2)));
8011
641
      if (!ce) {
8012
76
        HANDLE_EXCEPTION();
8013
76
      }
8014
641
    }
8015
565
    CACHE_PTR(opline->extended_value, ce);
8016
565
  }
8017
592
  ZEND_VM_NEXT_OPCODE();
8018
592
}
8019
8020
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8021
1.85k
{
8022
1.85k
  USE_OPLINE
8023
1.85k
  zval *name;
8024
1.85k
  zval *val;
8025
1.85k
  zend_constant c;
8026
8027
1.85k
  SAVE_OPLINE();
8028
1.85k
  name  = RT_CONSTANT(opline, opline->op1);
8029
1.85k
  val   = RT_CONSTANT(opline, opline->op2);
8030
8031
1.85k
  ZVAL_COPY(&c.value, val);
8032
1.85k
  if (Z_OPT_CONSTANT(c.value)) {
8033
933
    if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
8034
169
      zval_ptr_dtor_nogc(&c.value);
8035
8036
8037
169
      HANDLE_EXCEPTION();
8038
169
    }
8039
933
  }
8040
  /* non persistent, case sensitive */
8041
1.68k
  ZEND_CONSTANT_SET_FLAGS(&c, 0, PHP_USER_CONSTANT);
8042
1.68k
  c.name = zend_string_copy(Z_STR_P(name));
8043
8044
1.68k
  if (zend_register_constant(&c) == FAILURE) {
8045
24
  }
8046
8047
8048
1.68k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8049
1.68k
}
8050
8051
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8052
139
{
8053
139
  USE_OPLINE
8054
139
  zval *name;
8055
139
  zval *val;
8056
139
  zend_constant c;
8057
8058
139
  SAVE_OPLINE();
8059
139
  name  = RT_CONSTANT(opline, opline->op1);
8060
139
  val   = RT_CONSTANT(opline, opline->op2);
8061
8062
139
  ZVAL_COPY(&c.value, val);
8063
139
  if (Z_OPT_CONSTANT(c.value)) {
8064
5
    if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
8065
0
      zval_ptr_dtor_nogc(&c.value);
8066
8067
8068
0
      HANDLE_EXCEPTION();
8069
0
    }
8070
5
  }
8071
  /* non persistent, case sensitive */
8072
139
  ZEND_CONSTANT_SET_FLAGS(&c, 0, PHP_USER_CONSTANT);
8073
139
  c.name = zend_string_copy(Z_STR_P(name));
8074
8075
139
  if (zend_register_constant(&c) == FAILURE) {
8076
8077
8078
    /* two opcodes used, second one is the data with attributes */
8079
5
    ZEND_VM_NEXT_OPCODE_EX(1, 2);
8080
5
  }
8081
8082
134
  HashTable *attributes = Z_PTR_P(get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1));
8083
134
  zend_constant *registered = zend_get_constant_ptr(c.name);
8084
134
  ZEND_ASSERT(attributes != NULL);
8085
134
  ZEND_ASSERT(registered != NULL);
8086
134
  zend_constant_add_attributes(registered, attributes);
8087
8088
8089
  /* two opcodes used, second one is the data with attributes */
8090
134
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
8091
134
}
8092
8093
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8094
144
{
8095
144
  USE_OPLINE
8096
8097
144
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
8098
8099
144
  SAVE_OPLINE();
8100
144
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
8101
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8102
0
  }
8103
8104
  /* Destroy the previously yielded value */
8105
144
  zval_ptr_dtor(&generator->value);
8106
8107
  /* Destroy the previously yielded key */
8108
144
  zval_ptr_dtor(&generator->key);
8109
8110
  /* Set the new yielded value */
8111
144
  if (IS_CONST != IS_UNUSED) {
8112
144
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
8113
      /* Constants and temporary variables aren't yieldable by reference,
8114
       * but we still allow them with a notice. */
8115
0
      if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
8116
0
        zval *value;
8117
8118
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
8119
8120
0
        value = RT_CONSTANT(opline, opline->op1);
8121
0
        ZVAL_COPY_VALUE(&generator->value, value);
8122
0
        if (IS_CONST == IS_CONST) {
8123
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
8124
0
            Z_ADDREF(generator->value);
8125
0
          }
8126
0
        }
8127
0
      } else {
8128
0
        zval *value_ptr = zend_get_bad_ptr();
8129
8130
        /* If a function call result is yielded and the function did
8131
         * not return by reference we throw a notice. */
8132
0
        do {
8133
0
          if (IS_CONST == IS_VAR) {
8134
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
8135
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
8136
0
             && !Z_ISREF_P(value_ptr)) {
8137
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
8138
0
              ZVAL_COPY(&generator->value, value_ptr);
8139
0
              break;
8140
0
            }
8141
0
          }
8142
0
          if (Z_ISREF_P(value_ptr)) {
8143
0
            Z_ADDREF_P(value_ptr);
8144
0
          } else {
8145
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
8146
0
          }
8147
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
8148
0
        } while (0);
8149
8150
0
      }
8151
144
    } else {
8152
144
      zval *value = RT_CONSTANT(opline, opline->op1);
8153
8154
      /* Consts, temporary variables and references need copying */
8155
144
      if (IS_CONST == IS_CONST) {
8156
144
        ZVAL_COPY_VALUE(&generator->value, value);
8157
144
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
8158
0
          Z_ADDREF(generator->value);
8159
0
        }
8160
144
      } else if (IS_CONST == IS_TMP_VAR) {
8161
0
        ZVAL_COPY_VALUE(&generator->value, value);
8162
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
8163
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
8164
8165
0
      } else {
8166
0
        ZVAL_COPY_VALUE(&generator->value, value);
8167
0
        if (IS_CONST == IS_CV) {
8168
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
8169
0
        }
8170
0
      }
8171
144
    }
8172
144
  } else {
8173
    /* If no value was specified yield null */
8174
0
    ZVAL_NULL(&generator->value);
8175
0
  }
8176
8177
  /* Set the new yielded key */
8178
144
  if (IS_CONST != IS_UNUSED) {
8179
144
    zval *key = RT_CONSTANT(opline, opline->op2);
8180
144
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
8181
0
      key = Z_REFVAL_P(key);
8182
0
    }
8183
144
    ZVAL_COPY(&generator->key, key);
8184
8185
144
    if (Z_TYPE(generator->key) == IS_LONG
8186
144
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
8187
144
    ) {
8188
6
      generator->largest_used_integer_key = Z_LVAL(generator->key);
8189
6
    }
8190
144
  } else {
8191
    /* If no key was specified we use auto-increment keys */
8192
0
    generator->largest_used_integer_key++;
8193
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
8194
0
  }
8195
8196
144
  if (RETURN_VALUE_USED(opline)) {
8197
    /* If the return value of yield is used set the send
8198
     * target and initialize it to NULL */
8199
48
    generator->send_target = EX_VAR(opline->result.var);
8200
48
    ZVAL_NULL(generator->send_target);
8201
96
  } else {
8202
96
    generator->send_target = NULL;
8203
96
  }
8204
8205
  /* The GOTO VM uses a local opline variable. We need to set the opline
8206
   * variable in execute_data so we don't resume at an old position. */
8207
144
  SAVE_OPLINE();
8208
8209
144
  ZEND_VM_RETURN();
8210
144
}
8211
8212
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8213
0
{
8214
0
  USE_OPLINE
8215
0
  zval *op, *jump_zv;
8216
0
  HashTable *jumptable;
8217
8218
0
  op = RT_CONSTANT(opline, opline->op1);
8219
8220
0
  if (Z_TYPE_P(op) != IS_LONG) {
8221
0
    ZVAL_DEREF(op);
8222
0
    if (Z_TYPE_P(op) != IS_LONG) {
8223
      /* Wrong type, fall back to ZEND_CASE chain */
8224
0
      ZEND_VM_NEXT_OPCODE();
8225
0
    }
8226
0
  }
8227
8228
0
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8229
0
  jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
8230
0
  if (jump_zv != NULL) {
8231
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8232
0
    ZEND_VM_CONTINUE();
8233
0
  } else {
8234
    /* default */
8235
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8236
0
    ZEND_VM_CONTINUE();
8237
0
  }
8238
0
}
8239
8240
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8241
0
{
8242
0
  USE_OPLINE
8243
0
  zval *op, *jump_zv;
8244
0
  HashTable *jumptable;
8245
8246
0
  op = RT_CONSTANT(opline, opline->op1);
8247
8248
0
  if (Z_TYPE_P(op) != IS_STRING) {
8249
0
    if (IS_CONST == IS_CONST) {
8250
      /* Wrong type, fall back to ZEND_CASE chain */
8251
0
      ZEND_VM_NEXT_OPCODE();
8252
0
    } else {
8253
0
      ZVAL_DEREF(op);
8254
0
      if (Z_TYPE_P(op) != IS_STRING) {
8255
        /* Wrong type, fall back to ZEND_CASE chain */
8256
0
        ZEND_VM_NEXT_OPCODE();
8257
0
      }
8258
0
    }
8259
0
  }
8260
8261
0
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8262
0
  jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
8263
0
  if (jump_zv != NULL) {
8264
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8265
0
    ZEND_VM_CONTINUE();
8266
0
  } else {
8267
    /* default */
8268
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8269
0
    ZEND_VM_CONTINUE();
8270
0
  }
8271
0
}
8272
8273
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8274
0
{
8275
0
  USE_OPLINE
8276
0
  zval *op, *jump_zv;
8277
0
  HashTable *jumptable;
8278
8279
0
  op = RT_CONSTANT(opline, opline->op1);
8280
0
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8281
8282
0
match_try_again:
8283
0
  if (Z_TYPE_P(op) == IS_LONG) {
8284
0
    jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
8285
0
  } else if (Z_TYPE_P(op) == IS_STRING) {
8286
0
    jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
8287
0
  } else if (Z_TYPE_P(op) == IS_REFERENCE) {
8288
0
    op = Z_REFVAL_P(op);
8289
0
    goto match_try_again;
8290
0
  } else {
8291
0
    if (UNEXPECTED((IS_CONST & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
8292
0
      SAVE_OPLINE();
8293
0
      op = ZVAL_UNDEFINED_OP1();
8294
0
      if (UNEXPECTED(EG(exception))) {
8295
0
        HANDLE_EXCEPTION();
8296
0
      }
8297
0
      goto match_try_again;
8298
0
    }
8299
8300
0
    goto default_branch;
8301
0
  }
8302
8303
0
  if (jump_zv != NULL) {
8304
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8305
0
    ZEND_VM_CONTINUE();
8306
0
  } else {
8307
0
default_branch:
8308
    /* default */
8309
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8310
0
    ZEND_VM_CONTINUE();
8311
0
  }
8312
0
}
8313
8314
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8315
0
{
8316
0
  USE_OPLINE
8317
0
  zval *op1;
8318
0
  HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8319
0
  zval *result;
8320
8321
0
  op1 = RT_CONSTANT(opline, opline->op1);
8322
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8323
0
    result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CONST == IS_CONST);
8324
0
    if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8325
0
      zval_ptr_dtor_str(op1);
8326
0
    }
8327
0
    ZEND_VM_SMART_BRANCH(result, 0);
8328
0
  }
8329
8330
0
  if (opline->extended_value) {
8331
0
    if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8332
0
      result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8333
0
      ZEND_VM_SMART_BRANCH(result, 0);
8334
0
    }
8335
0
    SAVE_OPLINE();
8336
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8337
0
      op1 = Z_REFVAL_P(op1);
8338
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8339
0
        result = zend_hash_find(ht, Z_STR_P(op1));
8340
8341
0
        ZEND_VM_SMART_BRANCH(result, 0);
8342
0
      } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8343
0
        result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8344
8345
0
        ZEND_VM_SMART_BRANCH(result, 0);
8346
0
      }
8347
0
    } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8348
0
      ZVAL_UNDEFINED_OP1();
8349
0
    }
8350
0
  } else if (Z_TYPE_P(op1) <= IS_FALSE) {
8351
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8352
0
      SAVE_OPLINE();
8353
0
      ZVAL_UNDEFINED_OP1();
8354
0
      if (UNEXPECTED(EG(exception) != NULL)) {
8355
0
        HANDLE_EXCEPTION();
8356
0
      }
8357
0
    }
8358
0
    result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
8359
0
    ZEND_VM_SMART_BRANCH(result, 0);
8360
0
  } else {
8361
0
    zend_string *key;
8362
0
    zval key_tmp;
8363
8364
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8365
0
      op1 = Z_REFVAL_P(op1);
8366
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8367
0
        result = zend_hash_find(ht, Z_STR_P(op1));
8368
8369
0
        ZEND_VM_SMART_BRANCH(result, 0);
8370
0
      }
8371
0
    }
8372
8373
0
    SAVE_OPLINE();
8374
0
    ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
8375
0
      ZVAL_STR(&key_tmp, key);
8376
0
      if (zend_compare(op1, &key_tmp) == 0) {
8377
8378
0
        ZEND_VM_SMART_BRANCH(1, 1);
8379
0
      }
8380
0
    } ZEND_HASH_FOREACH_END();
8381
0
  }
8382
8383
0
  ZEND_VM_SMART_BRANCH(0, 1);
8384
0
}
8385
8386
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8387
2.94k
{
8388
2.94k
  USE_OPLINE
8389
2.94k
  zval *op1, *op2, *result;
8390
2.94k
  double d1, d2;
8391
8392
2.94k
  op1 = RT_CONSTANT(opline, opline->op1);
8393
2.94k
  op2 = EX_VAR(opline->op2.var);
8394
2.94k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8395
    /* pass */
8396
2.94k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8397
993
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8398
442
      result = EX_VAR(opline->result.var);
8399
442
      fast_long_add_function(result, op1, op2);
8400
442
      ZEND_VM_NEXT_OPCODE();
8401
551
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8402
113
      d1 = (double)Z_LVAL_P(op1);
8403
113
      d2 = Z_DVAL_P(op2);
8404
113
      goto add_double;
8405
113
    }
8406
1.95k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8407
104
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8408
29
      d1 = Z_DVAL_P(op1);
8409
29
      d2 = Z_DVAL_P(op2);
8410
203
add_double:
8411
203
      result = EX_VAR(opline->result.var);
8412
203
      ZVAL_DOUBLE(result, d1 + d2);
8413
203
      ZEND_VM_NEXT_OPCODE();
8414
203
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8415
61
      d1 = Z_DVAL_P(op1);
8416
61
      d2 = (double)Z_LVAL_P(op2);
8417
61
      goto add_double;
8418
61
    }
8419
104
  }
8420
8421
2.94k
  ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8422
2.94k
}
8423
8424
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8425
3.49k
{
8426
3.49k
  USE_OPLINE
8427
3.49k
  zval *op1, *op2, *result;
8428
3.49k
  double d1, d2;
8429
8430
3.49k
  op1 = RT_CONSTANT(opline, opline->op1);
8431
3.49k
  op2 = EX_VAR(opline->op2.var);
8432
3.49k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8433
    /* pass */
8434
3.49k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8435
3.15k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8436
1.39k
      result = EX_VAR(opline->result.var);
8437
1.39k
      fast_long_sub_function(result, op1, op2);
8438
1.39k
      ZEND_VM_NEXT_OPCODE();
8439
1.75k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8440
33
      d1 = (double)Z_LVAL_P(op1);
8441
33
      d2 = Z_DVAL_P(op2);
8442
33
      goto sub_double;
8443
33
    }
8444
3.15k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8445
327
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8446
46
      d1 = Z_DVAL_P(op1);
8447
46
      d2 = Z_DVAL_P(op2);
8448
358
sub_double:
8449
358
      result = EX_VAR(opline->result.var);
8450
358
      ZVAL_DOUBLE(result, d1 - d2);
8451
358
      ZEND_VM_NEXT_OPCODE();
8452
358
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8453
279
      d1 = Z_DVAL_P(op1);
8454
279
      d2 = (double)Z_LVAL_P(op2);
8455
279
      goto sub_double;
8456
279
    }
8457
327
  }
8458
8459
3.49k
  ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8460
3.49k
}
8461
8462
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8463
293
{
8464
293
  USE_OPLINE
8465
293
  zval *op1, *op2, *result;
8466
8467
293
  op1 = RT_CONSTANT(opline, opline->op1);
8468
293
  op2 = EX_VAR(opline->op2.var);
8469
293
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8470
    /* pass */
8471
293
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8472
288
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8473
259
      result = EX_VAR(opline->result.var);
8474
259
      if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
8475
13
        ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8476
246
      } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
8477
        /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
8478
6
        ZVAL_LONG(result, 0);
8479
240
      } else {
8480
240
        ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
8481
240
      }
8482
246
      ZEND_VM_NEXT_OPCODE();
8483
246
    }
8484
288
  }
8485
8486
293
  ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8487
293
}
8488
8489
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8490
2.39k
{
8491
2.39k
  USE_OPLINE
8492
2.39k
  zval *op1, *op2;
8493
8494
2.39k
  op1 = RT_CONSTANT(opline, opline->op1);
8495
2.39k
  op2 = EX_VAR(opline->op2.var);
8496
2.39k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8497
    /* pass */
8498
2.39k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8499
2.39k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8500
2.39k
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8501
    /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
8502
2.32k
    ZVAL_LONG(EX_VAR(opline->result.var),
8503
2.32k
      (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
8504
2.32k
    ZEND_VM_NEXT_OPCODE();
8505
2.32k
  }
8506
8507
2.39k
  ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8508
2.39k
}
8509
8510
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8511
1.05k
{
8512
1.05k
  USE_OPLINE
8513
1.05k
  zval *op1, *op2;
8514
8515
1.05k
  op1 = RT_CONSTANT(opline, opline->op1);
8516
1.05k
  op2 = EX_VAR(opline->op2.var);
8517
1.05k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8518
    /* pass */
8519
1.05k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8520
1.05k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8521
1.05k
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8522
967
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
8523
967
    ZEND_VM_NEXT_OPCODE();
8524
967
  }
8525
8526
1.05k
  ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8527
1.05k
}
8528
8529
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8530
2.04k
{
8531
2.04k
  USE_OPLINE
8532
2.04k
  zval *op1, *op2;
8533
2.04k
  double d1, d2;
8534
8535
2.04k
  op1 = RT_CONSTANT(opline, opline->op1);
8536
2.04k
  op2 = EX_VAR(opline->op2.var);
8537
2.04k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8538
    /* pass */
8539
2.04k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8540
1.10k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8541
1.03k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8542
210
is_smaller_true:
8543
210
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
8544
955
      } else {
8545
955
is_smaller_false:
8546
955
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
8547
955
      }
8548
1.03k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8549
21
      d1 = (double)Z_LVAL_P(op1);
8550
21
      d2 = Z_DVAL_P(op2);
8551
21
      goto is_smaller_double;
8552
21
    }
8553
1.10k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8554
375
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8555
0
      d1 = Z_DVAL_P(op1);
8556
0
      d2 = Z_DVAL_P(op2);
8557
129
is_smaller_double:
8558
129
      if (d1 < d2) {
8559
129
        goto is_smaller_true;
8560
129
      } else {
8561
0
        goto is_smaller_false;
8562
0
      }
8563
375
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8564
108
      d1 = Z_DVAL_P(op1);
8565
108
      d2 = (double)Z_LVAL_P(op2);
8566
108
      goto is_smaller_double;
8567
108
    }
8568
375
  }
8569
2.04k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8570
2.04k
}
8571
8572
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8573
1.31k
{
8574
1.31k
  USE_OPLINE
8575
1.31k
  zval *op1, *op2;
8576
1.31k
  double d1, d2;
8577
8578
1.31k
  op1 = RT_CONSTANT(opline, opline->op1);
8579
1.31k
  op2 = EX_VAR(opline->op2.var);
8580
1.31k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8581
    /* pass */
8582
1.31k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8583
1.14k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8584
928
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8585
300
is_smaller_true:
8586
300
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8587
637
      } else {
8588
757
is_smaller_false:
8589
757
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8590
757
      }
8591
928
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8592
0
      d1 = (double)Z_LVAL_P(op1);
8593
0
      d2 = Z_DVAL_P(op2);
8594
0
      goto is_smaller_double;
8595
0
    }
8596
1.14k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8597
162
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8598
19
      d1 = Z_DVAL_P(op1);
8599
19
      d2 = Z_DVAL_P(op2);
8600
129
is_smaller_double:
8601
129
      if (d1 < d2) {
8602
9
        goto is_smaller_true;
8603
120
      } else {
8604
120
        goto is_smaller_false;
8605
120
      }
8606
143
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8607
110
      d1 = Z_DVAL_P(op1);
8608
110
      d2 = (double)Z_LVAL_P(op2);
8609
110
      goto is_smaller_double;
8610
110
    }
8611
162
  }
8612
1.31k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8613
1.31k
}
8614
8615
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8616
576
{
8617
576
  USE_OPLINE
8618
576
  zval *op1, *op2;
8619
576
  double d1, d2;
8620
8621
576
  op1 = RT_CONSTANT(opline, opline->op1);
8622
576
  op2 = EX_VAR(opline->op2.var);
8623
576
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8624
    /* pass */
8625
576
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8626
572
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8627
366
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8628
9
is_smaller_true:
8629
9
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8630
357
      } else {
8631
359
is_smaller_false:
8632
359
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8633
359
      }
8634
366
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8635
0
      d1 = (double)Z_LVAL_P(op1);
8636
0
      d2 = Z_DVAL_P(op2);
8637
0
      goto is_smaller_double;
8638
0
    }
8639
572
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8640
4
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8641
0
      d1 = Z_DVAL_P(op1);
8642
0
      d2 = Z_DVAL_P(op2);
8643
2
is_smaller_double:
8644
2
      if (d1 < d2) {
8645
0
        goto is_smaller_true;
8646
2
      } else {
8647
2
        goto is_smaller_false;
8648
2
      }
8649
4
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8650
2
      d1 = Z_DVAL_P(op1);
8651
2
      d2 = (double)Z_LVAL_P(op2);
8652
2
      goto is_smaller_double;
8653
2
    }
8654
4
  }
8655
576
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8656
576
}
8657
8658
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8659
256
{
8660
256
  USE_OPLINE
8661
256
  zval *op1, *op2;
8662
256
  double d1, d2;
8663
8664
256
  op1 = RT_CONSTANT(opline, opline->op1);
8665
256
  op2 = EX_VAR(opline->op2.var);
8666
256
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8667
    /* pass */
8668
256
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8669
240
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8670
222
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8671
51
is_smaller_or_equal_true:
8672
51
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
8673
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
8674
0
        ZEND_VM_NEXT_OPCODE();
8675
171
      } else {
8676
171
is_smaller_or_equal_false:
8677
171
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
8678
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
8679
0
        ZEND_VM_NEXT_OPCODE();
8680
0
      }
8681
222
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8682
0
      d1 = (double)Z_LVAL_P(op1);
8683
0
      d2 = Z_DVAL_P(op2);
8684
0
      goto is_smaller_or_equal_double;
8685
0
    }
8686
240
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8687
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8688
0
      d1 = Z_DVAL_P(op1);
8689
0
      d2 = Z_DVAL_P(op2);
8690
0
is_smaller_or_equal_double:
8691
0
      if (d1 <= d2) {
8692
0
        goto is_smaller_or_equal_true;
8693
0
      } else {
8694
0
        goto is_smaller_or_equal_false;
8695
0
      }
8696
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8697
0
      d1 = Z_DVAL_P(op1);
8698
0
      d2 = (double)Z_LVAL_P(op2);
8699
0
      goto is_smaller_or_equal_double;
8700
0
    }
8701
0
  }
8702
256
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8703
256
}
8704
8705
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8706
1.82k
{
8707
1.82k
  USE_OPLINE
8708
1.82k
  zval *op1, *op2;
8709
1.82k
  double d1, d2;
8710
8711
1.82k
  op1 = RT_CONSTANT(opline, opline->op1);
8712
1.82k
  op2 = EX_VAR(opline->op2.var);
8713
1.82k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8714
    /* pass */
8715
1.82k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8716
1.82k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8717
1.36k
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8718
1.04k
is_smaller_or_equal_true:
8719
1.04k
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8720
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
8721
0
        ZEND_VM_NEXT_OPCODE();
8722
322
      } else {
8723
322
is_smaller_or_equal_false:
8724
322
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8725
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
8726
0
        ZEND_VM_NEXT_OPCODE();
8727
0
      }
8728
1.36k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8729
0
      d1 = (double)Z_LVAL_P(op1);
8730
0
      d2 = Z_DVAL_P(op2);
8731
0
      goto is_smaller_or_equal_double;
8732
0
    }
8733
1.82k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8734
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8735
0
      d1 = Z_DVAL_P(op1);
8736
0
      d2 = Z_DVAL_P(op2);
8737
0
is_smaller_or_equal_double:
8738
0
      if (d1 <= d2) {
8739
0
        goto is_smaller_or_equal_true;
8740
0
      } else {
8741
0
        goto is_smaller_or_equal_false;
8742
0
      }
8743
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8744
0
      d1 = Z_DVAL_P(op1);
8745
0
      d2 = (double)Z_LVAL_P(op2);
8746
0
      goto is_smaller_or_equal_double;
8747
0
    }
8748
0
  }
8749
1.82k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8750
1.82k
}
8751
8752
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8753
443
{
8754
443
  USE_OPLINE
8755
443
  zval *op1, *op2;
8756
443
  double d1, d2;
8757
8758
443
  op1 = RT_CONSTANT(opline, opline->op1);
8759
443
  op2 = EX_VAR(opline->op2.var);
8760
443
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8761
    /* pass */
8762
443
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8763
179
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8764
176
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8765
173
is_smaller_or_equal_true:
8766
173
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8767
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
8768
0
        ZEND_VM_NEXT_OPCODE();
8769
3
      } else {
8770
3
is_smaller_or_equal_false:
8771
3
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8772
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
8773
0
        ZEND_VM_NEXT_OPCODE();
8774
0
      }
8775
176
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8776
0
      d1 = (double)Z_LVAL_P(op1);
8777
0
      d2 = Z_DVAL_P(op2);
8778
0
      goto is_smaller_or_equal_double;
8779
0
    }
8780
264
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8781
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8782
0
      d1 = Z_DVAL_P(op1);
8783
0
      d2 = Z_DVAL_P(op2);
8784
0
is_smaller_or_equal_double:
8785
0
      if (d1 <= d2) {
8786
0
        goto is_smaller_or_equal_true;
8787
0
      } else {
8788
0
        goto is_smaller_or_equal_false;
8789
0
      }
8790
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8791
0
      d1 = Z_DVAL_P(op1);
8792
0
      d2 = (double)Z_LVAL_P(op2);
8793
0
      goto is_smaller_or_equal_double;
8794
0
    }
8795
0
  }
8796
443
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8797
443
}
8798
8799
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8800
224
{
8801
224
  zend_class_entry *ce, *scope;
8802
224
  zend_class_constant *c;
8803
224
  zval *value, *zv, *constant_zv;
8804
224
  zend_string *constant_name;
8805
224
  USE_OPLINE
8806
8807
224
  SAVE_OPLINE();
8808
8809
224
  do {
8810
224
    if (IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8811
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
8812
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
8813
0
        break;
8814
0
      }
8815
0
    }
8816
224
    if (IS_CONST == IS_CONST) {
8817
224
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
8818
10
        ce = CACHED_PTR(opline->extended_value);
8819
214
      } else {
8820
214
        ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
8821
214
        if (UNEXPECTED(ce == NULL)) {
8822
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
8823
0
          FREE_OP(opline->op2_type, opline->op2.var);
8824
0
          HANDLE_EXCEPTION();
8825
0
        }
8826
214
        CACHE_PTR(opline->extended_value, ce);
8827
214
      }
8828
224
    } else if (IS_CONST == IS_UNUSED) {
8829
0
      ce = zend_fetch_class(NULL, opline->op1.num);
8830
0
      if (UNEXPECTED(ce == NULL)) {
8831
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
8832
0
        FREE_OP(opline->op2_type, opline->op2.var);
8833
0
        HANDLE_EXCEPTION();
8834
0
      }
8835
0
    } else {
8836
0
      ce = Z_CE_P(EX_VAR(opline->op1.var));
8837
0
    }
8838
224
    if (IS_CONST != IS_CONST
8839
224
      && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8840
224
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
8841
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
8842
0
      break;
8843
0
    }
8844
8845
224
    constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
8846
224
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
8847
82
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
8848
82
      ZVAL_UNDEF(EX_VAR(opline->result.var));
8849
82
      FREE_OP(opline->op2_type, opline->op2.var);
8850
82
      HANDLE_EXCEPTION();
8851
82
    }
8852
142
    constant_name = Z_STR_P(constant_zv);
8853
    /* Magic 'class' for constant OP2 is caught at compile-time */
8854
142
    if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
8855
24
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
8856
24
      FREE_OP(opline->op2_type, opline->op2.var);
8857
24
      ZEND_VM_NEXT_OPCODE();
8858
24
    }
8859
118
    zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8860
118
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
8861
118
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
8862
8863
118
    if (EXPECTED(zv != NULL)) {
8864
110
      c = Z_PTR_P(zv);
8865
110
      scope = EX(func)->op_array.scope;
8866
110
      if (!zend_verify_const_access(c, scope)) {
8867
0
        zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8868
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
8869
0
        FREE_OP(opline->op2_type, opline->op2.var);
8870
0
        HANDLE_EXCEPTION();
8871
0
      }
8872
8873
110
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
8874
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8875
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
8876
0
        FREE_OP(opline->op2_type, opline->op2.var);
8877
0
        HANDLE_EXCEPTION();
8878
0
      }
8879
8880
110
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
8881
110
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
8882
0
        if (c->ce->type == ZEND_USER_CLASS) {
8883
          /* Recursion protection only applied to user constants, GH-18463 */
8884
0
          CONST_PROTECT_RECURSION(c);
8885
0
        }
8886
0
        zend_deprecated_class_constant(c, constant_name);
8887
0
        if (c->ce->type == ZEND_USER_CLASS) {
8888
0
          CONST_UNPROTECT_RECURSION(c);
8889
0
        }
8890
8891
0
        if (EG(exception)) {
8892
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
8893
0
          FREE_OP(opline->op2_type, opline->op2.var);
8894
0
          HANDLE_EXCEPTION();
8895
0
        }
8896
0
      }
8897
8898
110
      value = &c->value;
8899
      // Enums require loading of all class constants to build the backed enum table
8900
110
      if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
8901
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
8902
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
8903
0
          FREE_OP(opline->op2_type, opline->op2.var);
8904
0
          HANDLE_EXCEPTION();
8905
0
        }
8906
0
      }
8907
110
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
8908
0
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
8909
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
8910
0
          FREE_OP(opline->op2_type, opline->op2.var);
8911
0
          HANDLE_EXCEPTION();
8912
0
        }
8913
0
      }
8914
110
      if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
8915
0
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
8916
0
      }
8917
110
    } else {
8918
8
      zend_throw_error(NULL, "Undefined constant %s::%s",
8919
8
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8920
8
      ZVAL_UNDEF(EX_VAR(opline->result.var));
8921
8
      FREE_OP(opline->op2_type, opline->op2.var);
8922
8
      HANDLE_EXCEPTION();
8923
8
    }
8924
118
  } while (0);
8925
8926
110
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
8927
8928
110
  FREE_OP(opline->op2_type, opline->op2.var);
8929
110
  ZEND_VM_NEXT_OPCODE();
8930
110
}
8931
8932
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8933
250
{
8934
250
  USE_OPLINE
8935
250
  zval *op1, *op2, *result;
8936
8937
250
  op1 = RT_CONSTANT(opline, opline->op1);
8938
250
  op2 = EX_VAR(opline->op2.var);
8939
250
  result = EX_VAR(opline->result.var);
8940
250
  ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
8941
250
  ZEND_VM_NEXT_OPCODE();
8942
250
}
8943
8944
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8945
234
{
8946
234
  USE_OPLINE
8947
234
  zval *op1, *op2, *result;
8948
8949
234
  op1 = RT_CONSTANT(opline, opline->op1);
8950
234
  op2 = EX_VAR(opline->op2.var);
8951
234
  result = EX_VAR(opline->result.var);
8952
234
  fast_long_sub_function(result, op1, op2);
8953
234
  ZEND_VM_NEXT_OPCODE();
8954
234
}
8955
8956
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8957
0
{
8958
0
  USE_OPLINE
8959
0
  zval *op1, *op2, *result;
8960
8961
0
  op1 = RT_CONSTANT(opline, opline->op1);
8962
0
  op2 = EX_VAR(opline->op2.var);
8963
0
  result = EX_VAR(opline->result.var);
8964
0
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
8965
0
  ZEND_VM_NEXT_OPCODE();
8966
0
}
8967
8968
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8969
55
{
8970
55
  USE_OPLINE
8971
55
  zval *op1, *op2;
8972
55
  bool result;
8973
8974
55
  op1 = RT_CONSTANT(opline, opline->op1);
8975
55
  op2 = EX_VAR(opline->op2.var);
8976
55
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8977
55
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
8978
55
}
8979
8980
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8981
252
{
8982
252
  USE_OPLINE
8983
252
  zval *op1, *op2;
8984
252
  bool result;
8985
8986
252
  op1 = RT_CONSTANT(opline, opline->op1);
8987
252
  op2 = EX_VAR(opline->op2.var);
8988
252
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8989
252
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8990
252
}
8991
8992
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8993
19
{
8994
19
  USE_OPLINE
8995
19
  zval *op1, *op2;
8996
19
  bool result;
8997
8998
19
  op1 = RT_CONSTANT(opline, opline->op1);
8999
19
  op2 = EX_VAR(opline->op2.var);
9000
19
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
9001
19
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9002
19
}
9003
9004
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9005
71
{
9006
71
  USE_OPLINE
9007
71
  zval *op1, *op2;
9008
71
  bool result;
9009
9010
71
  op1 = RT_CONSTANT(opline, opline->op1);
9011
71
  op2 = EX_VAR(opline->op2.var);
9012
71
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
9013
71
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
9014
71
}
9015
9016
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9017
0
{
9018
0
  USE_OPLINE
9019
0
  zval *op1, *op2;
9020
0
  bool result;
9021
9022
0
  op1 = RT_CONSTANT(opline, opline->op1);
9023
0
  op2 = EX_VAR(opline->op2.var);
9024
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
9025
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
9026
0
}
9027
9028
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9029
0
{
9030
0
  USE_OPLINE
9031
0
  zval *op1, *op2;
9032
0
  bool result;
9033
9034
0
  op1 = RT_CONSTANT(opline, opline->op1);
9035
0
  op2 = EX_VAR(opline->op2.var);
9036
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
9037
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9038
0
}
9039
9040
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9041
5
{
9042
5
  USE_OPLINE
9043
5
  zval *op1, *op2;
9044
5
  bool result;
9045
9046
5
  op1 = RT_CONSTANT(opline, opline->op1);
9047
5
  op2 = EX_VAR(opline->op2.var);
9048
5
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
9049
5
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
9050
5
}
9051
9052
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9053
728
{
9054
728
  USE_OPLINE
9055
728
  zval *op1, *op2;
9056
728
  bool result;
9057
9058
728
  op1 = RT_CONSTANT(opline, opline->op1);
9059
728
  op2 = EX_VAR(opline->op2.var);
9060
728
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
9061
728
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
9062
728
}
9063
9064
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9065
0
{
9066
0
  USE_OPLINE
9067
0
  zval *op1, *op2;
9068
0
  bool result;
9069
9070
0
  op1 = RT_CONSTANT(opline, opline->op1);
9071
0
  op2 = EX_VAR(opline->op2.var);
9072
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
9073
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9074
0
}
9075
9076
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9077
0
{
9078
0
  USE_OPLINE
9079
0
  zval *op1, *op2;
9080
0
  bool result;
9081
9082
0
  op1 = RT_CONSTANT(opline, opline->op1);
9083
0
  op2 = EX_VAR(opline->op2.var);
9084
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
9085
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
9086
0
}
9087
9088
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9089
0
{
9090
0
  USE_OPLINE
9091
0
  zval *op1, *op2;
9092
0
  bool result;
9093
9094
0
  op1 = RT_CONSTANT(opline, opline->op1);
9095
0
  op2 = EX_VAR(opline->op2.var);
9096
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
9097
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
9098
0
}
9099
9100
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9101
0
{
9102
0
  USE_OPLINE
9103
0
  zval *op1, *op2;
9104
0
  bool result;
9105
9106
0
  op1 = RT_CONSTANT(opline, opline->op1);
9107
0
  op2 = EX_VAR(opline->op2.var);
9108
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
9109
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9110
0
}
9111
9112
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9113
160
{
9114
160
  USE_OPLINE
9115
160
  zval *container, *dim, *value;
9116
160
  zend_long offset;
9117
160
  HashTable *ht;
9118
9119
160
  container = RT_CONSTANT(opline, opline->op1);
9120
160
  dim = EX_VAR(opline->op2.var);
9121
160
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9122
40
fetch_dim_r_index_array:
9123
40
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
9124
38
      offset = Z_LVAL_P(dim);
9125
38
    } else {
9126
2
      SAVE_OPLINE();
9127
2
      zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
9128
9129
2
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9130
2
    }
9131
38
    ht = Z_ARRVAL_P(container);
9132
38
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
9133
19
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
9134
19
    if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9135
0
      SAVE_OPLINE();
9136
9137
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9138
19
    } else {
9139
19
      ZEND_VM_NEXT_OPCODE();
9140
19
    }
9141
120
  } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
9142
0
    container = Z_REFVAL_P(container);
9143
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9144
0
      goto fetch_dim_r_index_array;
9145
0
    } else {
9146
0
      goto fetch_dim_r_index_slow;
9147
0
    }
9148
120
  } else {
9149
120
fetch_dim_r_index_slow:
9150
120
    SAVE_OPLINE();
9151
120
    if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
9152
0
      dim++;
9153
0
    }
9154
120
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
9155
9156
120
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9157
120
  }
9158
9159
19
fetch_dim_r_index_undef:
9160
19
  ZVAL_NULL(EX_VAR(opline->result.var));
9161
19
  SAVE_OPLINE();
9162
19
  zend_undefined_offset(offset);
9163
9164
19
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9165
19
}
9166
9167
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9168
14
{
9169
14
  USE_OPLINE
9170
14
  zval *op1, *op2;
9171
9172
14
  SAVE_OPLINE();
9173
14
  op1 = RT_CONSTANT(opline, opline->op1);
9174
14
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9175
14
  div_function(EX_VAR(opline->result.var), op1, op2);
9176
9177
14
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9178
14
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9179
14
}
9180
9181
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9182
0
{
9183
0
  USE_OPLINE
9184
0
  zval *op1, *op2;
9185
9186
0
  SAVE_OPLINE();
9187
0
  op1 = RT_CONSTANT(opline, opline->op1);
9188
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9189
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
9190
9191
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9192
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9193
0
}
9194
9195
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9196
1.55k
{
9197
1.55k
  USE_OPLINE
9198
1.55k
  zval *op1, *op2;
9199
9200
1.55k
  op1 = RT_CONSTANT(opline, opline->op1);
9201
1.55k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9202
9203
1.55k
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9204
1.55k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9205
692
    zend_string *op1_str = Z_STR_P(op1);
9206
692
    zend_string *op2_str = Z_STR_P(op2);
9207
692
    zend_string *str;
9208
692
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9209
9210
692
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9211
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9212
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9213
0
      } else {
9214
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9215
0
      }
9216
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9217
0
        zend_string_release_ex(op1_str, 0);
9218
0
      }
9219
692
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9220
8
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9221
8
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9222
8
      } else {
9223
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9224
0
      }
9225
8
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9226
8
        zend_string_release_ex(op2_str, 0);
9227
8
      }
9228
684
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9229
684
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9230
0
      size_t len = ZSTR_LEN(op1_str);
9231
9232
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
9233
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
9234
0
      }
9235
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9236
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9237
0
      GC_ADD_FLAGS(str, flags);
9238
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9239
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9240
0
        zend_string_release_ex(op2_str, 0);
9241
0
      }
9242
684
    } else {
9243
684
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9244
684
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9245
684
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9246
684
      GC_ADD_FLAGS(str, flags);
9247
684
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9248
684
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9249
0
        zend_string_release_ex(op1_str, 0);
9250
0
      }
9251
684
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9252
684
        zend_string_release_ex(op2_str, 0);
9253
684
      }
9254
684
    }
9255
692
    ZEND_VM_NEXT_OPCODE();
9256
859
  } else {
9257
859
    SAVE_OPLINE();
9258
9259
859
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9260
0
      op1 = ZVAL_UNDEFINED_OP1();
9261
0
    }
9262
859
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9263
0
      op2 = ZVAL_UNDEFINED_OP2();
9264
0
    }
9265
859
    concat_function(EX_VAR(opline->result.var), op1, op2);
9266
9267
859
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9268
859
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9269
859
  }
9270
1.55k
}
9271
9272
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9273
0
{
9274
0
  USE_OPLINE
9275
0
  zval *op1, *op2;
9276
9277
0
  SAVE_OPLINE();
9278
0
  op1 = RT_CONSTANT(opline, opline->op1);
9279
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9280
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
9281
9282
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9283
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9284
0
}
9285
9286
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9287
0
{
9288
0
  USE_OPLINE
9289
0
  zval *container, *dim, *value;
9290
9291
0
  SAVE_OPLINE();
9292
0
  container = RT_CONSTANT(opline, opline->op1);
9293
0
  dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9294
0
  if (IS_CONST != IS_CONST) {
9295
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9296
0
fetch_dim_r_array:
9297
0
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
9298
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
9299
0
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
9300
0
      container = Z_REFVAL_P(container);
9301
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9302
0
        goto fetch_dim_r_array;
9303
0
      } else {
9304
0
        goto fetch_dim_r_slow;
9305
0
      }
9306
0
    } else {
9307
0
fetch_dim_r_slow:
9308
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
9309
0
        dim++;
9310
0
      }
9311
0
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
9312
0
    }
9313
0
  } else {
9314
0
    zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
9315
0
  }
9316
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9317
9318
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9319
0
}
9320
9321
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9322
0
{
9323
0
  USE_OPLINE
9324
0
  zval *container;
9325
9326
0
  SAVE_OPLINE();
9327
0
  container = RT_CONSTANT(opline, opline->op1);
9328
0
  zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
9329
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9330
9331
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9332
0
}
9333
9334
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9335
0
{
9336
#if 0
9337
  USE_OPLINE
9338
#endif
9339
9340
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9341
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9342
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9343
0
    }
9344
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9345
0
  } else {
9346
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
9347
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9348
0
    }
9349
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9350
0
  }
9351
0
}
9352
9353
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9354
0
{
9355
0
  USE_OPLINE
9356
0
  zval *container;
9357
0
  void **cache_slot = NULL;
9358
9359
0
  SAVE_OPLINE();
9360
0
  container = RT_CONSTANT(opline, opline->op1);
9361
9362
0
  if (IS_CONST == IS_CONST ||
9363
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9364
0
    do {
9365
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9366
0
        container = Z_REFVAL_P(container);
9367
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9368
0
          break;
9369
0
        }
9370
0
      }
9371
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
9372
0
        ZVAL_UNDEFINED_OP1();
9373
0
      }
9374
0
      zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9375
0
      ZVAL_NULL(EX_VAR(opline->result.var));
9376
0
      goto fetch_obj_r_finish;
9377
0
    } while (0);
9378
0
  }
9379
9380
  /* here we are sure we are dealing with an object */
9381
0
  do {
9382
0
    zend_object *zobj = Z_OBJ_P(container);
9383
0
    zend_string *name, *tmp_name;
9384
0
    zval *retval;
9385
9386
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9387
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
9388
9389
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9390
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9391
9392
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9393
0
fetch_obj_r_simple:
9394
0
          retval = OBJ_PROP(zobj, prop_offset);
9395
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
9396
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9397
0
              goto fetch_obj_r_copy;
9398
0
            } else {
9399
0
fetch_obj_r_fast_copy:
9400
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9401
0
              ZEND_VM_NEXT_OPCODE();
9402
0
            }
9403
0
          }
9404
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
9405
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
9406
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
9407
0
            prop_offset = prop_info->offset;
9408
0
            goto fetch_obj_r_simple;
9409
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
9410
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
9411
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
9412
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
9413
9414
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9415
0
            if (IS_CONST & IS_CV) {
9416
0
              GC_ADDREF(zobj);
9417
0
            }
9418
0
            if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
9419
0
              call_info |= ZEND_CALL_RELEASE_THIS;
9420
0
            }
9421
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
9422
0
            call->prev_execute_data = execute_data;
9423
0
            call->call = NULL;
9424
0
            call->return_value = EX_VAR(opline->result.var);
9425
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
9426
9427
0
            execute_data = call;
9428
0
            EG(current_execute_data) = execute_data;
9429
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
9430
9431
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
9432
            opline = hook->op_array.opcodes;
9433
#else
9434
0
            EX(opline) = hook->op_array.opcodes;
9435
0
#endif
9436
0
            LOAD_OPLINE_EX();
9437
9438
9439
0
            ZEND_VM_ENTER_EX();
9440
0
          }
9441
          /* Fall through to read_property for hooks. */
9442
0
        } else if (EXPECTED(zobj->properties != NULL)) {
9443
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
9444
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9445
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9446
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9447
9448
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9449
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9450
9451
0
              if (EXPECTED(p->key == name) ||
9452
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
9453
0
                   EXPECTED(p->key != NULL) &&
9454
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
9455
0
                retval = &p->val;
9456
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9457
0
                  goto fetch_obj_r_copy;
9458
0
                } else {
9459
0
                  goto fetch_obj_r_fast_copy;
9460
0
                }
9461
0
              }
9462
0
            }
9463
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9464
0
          }
9465
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
9466
0
          if (EXPECTED(retval)) {
9467
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9468
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9469
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9470
0
              goto fetch_obj_r_copy;
9471
0
            } else {
9472
0
              goto fetch_obj_r_fast_copy;
9473
0
            }
9474
0
          }
9475
0
        }
9476
0
      }
9477
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9478
0
    } else {
9479
0
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9480
0
      if (UNEXPECTED(!name)) {
9481
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
9482
0
        break;
9483
0
      }
9484
0
    }
9485
9486
0
#if ZEND_DEBUG
9487
    /* For non-standard object handlers, verify a declared property type in debug builds.
9488
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
9489
0
    zend_property_info *prop_info = NULL;
9490
0
    if (zobj->handlers->read_property != zend_std_read_property) {
9491
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
9492
0
    }
9493
0
#endif
9494
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
9495
0
#if ZEND_DEBUG
9496
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
9497
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
9498
0
      ZVAL_OPT_DEREF(retval);
9499
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
9500
0
    }
9501
0
#endif
9502
9503
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9504
0
      zend_tmp_string_release(tmp_name);
9505
0
    }
9506
9507
0
    if (retval != EX_VAR(opline->result.var)) {
9508
0
fetch_obj_r_copy:
9509
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9510
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9511
0
      zend_unwrap_reference(retval);
9512
0
    }
9513
0
  } while (0);
9514
9515
0
fetch_obj_r_finish:
9516
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9517
9518
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9519
0
}
9520
9521
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9522
0
{
9523
0
  USE_OPLINE
9524
0
  zval *container;
9525
0
  void **cache_slot = NULL;
9526
9527
0
  SAVE_OPLINE();
9528
0
  container = RT_CONSTANT(opline, opline->op1);
9529
9530
0
  if (IS_CONST == IS_CONST ||
9531
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9532
0
    do {
9533
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9534
0
        container = Z_REFVAL_P(container);
9535
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9536
0
          break;
9537
0
        }
9538
0
      }
9539
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
9540
0
        ZVAL_UNDEFINED_OP2();
9541
0
      }
9542
0
      ZVAL_NULL(EX_VAR(opline->result.var));
9543
0
      goto fetch_obj_is_finish;
9544
0
    } while (0);
9545
0
  }
9546
9547
  /* here we are sure we are dealing with an object */
9548
0
  do {
9549
0
    zend_object *zobj = Z_OBJ_P(container);
9550
0
    zend_string *name, *tmp_name;
9551
0
    zval *retval;
9552
9553
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9554
0
      cache_slot = CACHE_ADDR(opline->extended_value);
9555
9556
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9557
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9558
9559
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9560
0
fetch_obj_is_simple:
9561
0
          retval = OBJ_PROP(zobj, prop_offset);
9562
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
9563
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9564
0
              goto fetch_obj_is_copy;
9565
0
            } else {
9566
0
fetch_obj_is_fast_copy:
9567
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9568
0
              ZEND_VM_NEXT_OPCODE();
9569
0
            }
9570
0
          }
9571
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
9572
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
9573
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
9574
0
            prop_offset = prop_info->offset;
9575
0
            goto fetch_obj_is_simple;
9576
0
          }
9577
          /* Fall through to read_property for hooks. */
9578
0
        } else if (EXPECTED(zobj->properties != NULL)) {
9579
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
9580
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9581
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9582
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9583
9584
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9585
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9586
9587
0
              if (EXPECTED(p->key == name) ||
9588
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
9589
0
                   EXPECTED(p->key != NULL) &&
9590
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
9591
0
                retval = &p->val;
9592
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9593
0
                  goto fetch_obj_is_copy;
9594
0
                } else {
9595
0
                  goto fetch_obj_is_fast_copy;
9596
0
                }
9597
0
              }
9598
0
            }
9599
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9600
0
          }
9601
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
9602
0
          if (EXPECTED(retval)) {
9603
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9604
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9605
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9606
0
              goto fetch_obj_is_copy;
9607
0
            } else {
9608
0
              goto fetch_obj_is_fast_copy;
9609
0
            }
9610
0
          }
9611
0
        }
9612
0
      }
9613
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9614
0
    } else {
9615
0
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9616
0
      if (UNEXPECTED(!name)) {
9617
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
9618
0
        break;
9619
0
      }
9620
0
    }
9621
9622
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
9623
9624
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9625
0
      zend_tmp_string_release(tmp_name);
9626
0
    }
9627
9628
0
    if (retval != EX_VAR(opline->result.var)) {
9629
0
fetch_obj_is_copy:
9630
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9631
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9632
0
      zend_unwrap_reference(retval);
9633
0
    }
9634
0
  } while (0);
9635
9636
0
fetch_obj_is_finish:
9637
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9638
9639
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9640
0
}
9641
9642
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9643
0
{
9644
#if 0
9645
  USE_OPLINE
9646
#endif
9647
9648
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9649
    /* Behave like FETCH_OBJ_W */
9650
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9651
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9652
0
    }
9653
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9654
0
  } else {
9655
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9656
0
  }
9657
0
}
9658
9659
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9660
0
{
9661
0
  USE_OPLINE
9662
0
  zval *container;
9663
9664
0
  SAVE_OPLINE();
9665
0
  container = RT_CONSTANT(opline, opline->op1);
9666
0
  zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
9667
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9668
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9669
0
}
9670
9671
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9672
204k
{
9673
204k
  USE_OPLINE
9674
204k
  zval *op1, *op2;
9675
204k
  zend_string *op1_str, *op2_str, *str;
9676
9677
9678
204k
  op1 = RT_CONSTANT(opline, opline->op1);
9679
204k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9680
204k
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9681
204k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9682
204k
    zend_string *op1_str = Z_STR_P(op1);
9683
204k
    zend_string *op2_str = Z_STR_P(op2);
9684
204k
    zend_string *str;
9685
204k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9686
9687
204k
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9688
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9689
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9690
0
      } else {
9691
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9692
0
      }
9693
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9694
0
        zend_string_release_ex(op1_str, 0);
9695
0
      }
9696
204k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9697
148
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9698
148
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9699
148
      } else {
9700
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9701
0
      }
9702
148
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9703
148
        zend_string_release_ex(op2_str, 0);
9704
148
      }
9705
203k
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9706
203k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9707
0
      size_t len = ZSTR_LEN(op1_str);
9708
9709
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9710
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9711
0
      GC_ADD_FLAGS(str, flags);
9712
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9713
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9714
0
        zend_string_release_ex(op2_str, 0);
9715
0
      }
9716
203k
    } else {
9717
203k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9718
203k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9719
203k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9720
203k
      GC_ADD_FLAGS(str, flags);
9721
203k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9722
203k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9723
0
        zend_string_release_ex(op1_str, 0);
9724
0
      }
9725
203k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9726
203k
        zend_string_release_ex(op2_str, 0);
9727
203k
      }
9728
203k
    }
9729
204k
    ZEND_VM_NEXT_OPCODE();
9730
204k
  }
9731
9732
204k
  SAVE_OPLINE();
9733
137
  if (IS_CONST == IS_CONST) {
9734
137
    op1_str = Z_STR_P(op1);
9735
137
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
9736
0
    op1_str = zend_string_copy(Z_STR_P(op1));
9737
0
  } else {
9738
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9739
0
      ZVAL_UNDEFINED_OP1();
9740
0
    }
9741
0
    op1_str = zval_get_string_func(op1);
9742
0
  }
9743
137
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9744
0
    op2_str = Z_STR_P(op2);
9745
137
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
9746
0
    op2_str = zend_string_copy(Z_STR_P(op2));
9747
137
  } else {
9748
137
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9749
0
      ZVAL_UNDEFINED_OP2();
9750
0
    }
9751
137
    op2_str = zval_get_string_func(op2);
9752
137
  }
9753
137
  do {
9754
137
    if (IS_CONST != IS_CONST) {
9755
0
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9756
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9757
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
9758
0
            GC_ADDREF(op2_str);
9759
0
          }
9760
0
        }
9761
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9762
0
        zend_string_release_ex(op1_str, 0);
9763
0
        break;
9764
0
      }
9765
0
    }
9766
137
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9767
137
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9768
75
        if (IS_CONST == IS_CONST) {
9769
75
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
9770
0
            GC_ADDREF(op1_str);
9771
0
          }
9772
75
        }
9773
75
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9774
75
        zend_string_release_ex(op2_str, 0);
9775
75
        break;
9776
75
      }
9777
137
    }
9778
62
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9779
62
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9780
62
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9781
9782
62
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
9783
62
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9784
62
    if (IS_CONST != IS_CONST) {
9785
0
      zend_string_release_ex(op1_str, 0);
9786
0
    }
9787
62
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9788
62
      zend_string_release_ex(op2_str, 0);
9789
62
    }
9790
62
  } while (0);
9791
9792
137
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9793
137
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9794
137
}
9795
9796
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9797
0
{
9798
0
  USE_OPLINE
9799
0
  zval *function_name;
9800
0
  zval *object;
9801
0
  zend_function *fbc;
9802
0
  zend_class_entry *called_scope;
9803
0
  zend_object *obj;
9804
0
  zend_execute_data *call;
9805
0
  uint32_t call_info;
9806
9807
0
  SAVE_OPLINE();
9808
9809
0
  object = RT_CONSTANT(opline, opline->op1);
9810
9811
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9812
0
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9813
0
  }
9814
9815
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
9816
0
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9817
0
    do {
9818
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
9819
0
        function_name = Z_REFVAL_P(function_name);
9820
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9821
0
          break;
9822
0
        }
9823
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9824
0
        ZVAL_UNDEFINED_OP2();
9825
0
        if (UNEXPECTED(EG(exception) != NULL)) {
9826
9827
0
          HANDLE_EXCEPTION();
9828
0
        }
9829
0
      }
9830
0
      zend_throw_error(NULL, "Method name must be a string");
9831
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9832
9833
0
      HANDLE_EXCEPTION();
9834
0
    } while (0);
9835
0
  }
9836
9837
0
  if (IS_CONST == IS_UNUSED) {
9838
0
    obj = Z_OBJ_P(object);
9839
0
  } else {
9840
0
    do {
9841
0
      if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9842
0
        obj = Z_OBJ_P(object);
9843
0
      } else {
9844
0
        if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
9845
0
          zend_reference *ref = Z_REF_P(object);
9846
9847
0
          object = &ref->val;
9848
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9849
0
            obj = Z_OBJ_P(object);
9850
0
            if (IS_CONST & IS_VAR) {
9851
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
9852
0
                efree_size(ref, sizeof(zend_reference));
9853
0
              } else {
9854
0
                Z_ADDREF_P(object);
9855
0
              }
9856
0
            }
9857
0
            break;
9858
0
          }
9859
0
        }
9860
0
        if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
9861
0
          object = ZVAL_UNDEFINED_OP1();
9862
0
          if (UNEXPECTED(EG(exception) != NULL)) {
9863
0
            if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9864
0
              zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9865
0
            }
9866
0
            HANDLE_EXCEPTION();
9867
0
          }
9868
0
        }
9869
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9870
0
          function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9871
0
        }
9872
0
        zend_invalid_method_call(object, function_name);
9873
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9874
9875
0
        HANDLE_EXCEPTION();
9876
0
      }
9877
0
    } while (0);
9878
0
  }
9879
9880
0
  called_scope = obj->ce;
9881
9882
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9883
0
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
9884
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9885
0
  } else {
9886
0
    zend_object *orig_obj = obj;
9887
9888
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9889
0
      function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9890
0
    }
9891
9892
    /* First, locate the function. */
9893
0
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
9894
0
    if (UNEXPECTED(fbc == NULL)) {
9895
0
      if (EXPECTED(!EG(exception))) {
9896
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
9897
0
      }
9898
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9899
0
      if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
9900
0
        zend_objects_store_del(orig_obj);
9901
0
      }
9902
0
      HANDLE_EXCEPTION();
9903
0
    }
9904
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9905
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9906
0
        EXPECTED(obj == orig_obj)) {
9907
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
9908
0
    }
9909
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
9910
0
      GC_ADDREF(obj); /* For $this pointer */
9911
0
      if (GC_DELREF(orig_obj) == 0) {
9912
0
        zend_objects_store_del(orig_obj);
9913
0
      }
9914
0
    }
9915
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9916
0
      init_func_run_time_cache(&fbc->op_array);
9917
0
    }
9918
0
  }
9919
9920
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9921
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9922
0
  }
9923
9924
0
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9925
0
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
9926
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
9927
0
      zend_objects_store_del(obj);
9928
0
      if (UNEXPECTED(EG(exception))) {
9929
0
        HANDLE_EXCEPTION();
9930
0
      }
9931
0
    }
9932
    /* call static method */
9933
0
    obj = (zend_object*)called_scope;
9934
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
9935
0
  } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
9936
0
    if (IS_CONST == IS_CV) {
9937
0
      GC_ADDREF(obj); /* For $this pointer */
9938
0
    }
9939
    /* CV may be changed indirectly (e.g. when it's a reference) */
9940
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
9941
0
  }
9942
9943
0
  call = zend_vm_stack_push_call_frame(call_info,
9944
0
    fbc, opline->extended_value, obj);
9945
0
  call->prev_execute_data = EX(call);
9946
0
  EX(call) = call;
9947
9948
0
  ZEND_VM_NEXT_OPCODE();
9949
0
}
9950
9951
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9952
25
{
9953
25
  USE_OPLINE
9954
25
  zval *function_name;
9955
25
  zend_class_entry *ce;
9956
25
  uint32_t call_info;
9957
25
  zend_function *fbc;
9958
25
  zend_execute_data *call;
9959
9960
25
  SAVE_OPLINE();
9961
9962
25
  if (IS_CONST == IS_CONST) {
9963
    /* no function found. try a static method in class */
9964
25
    ce = CACHED_PTR(opline->result.num);
9965
25
    if (UNEXPECTED(ce == NULL)) {
9966
15
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
9967
15
      if (UNEXPECTED(ce == NULL)) {
9968
5
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9969
5
        HANDLE_EXCEPTION();
9970
5
      }
9971
10
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9972
10
        CACHE_PTR(opline->result.num, ce);
9973
10
      }
9974
10
    }
9975
25
  } else if (IS_CONST == IS_UNUSED) {
9976
0
    ce = zend_fetch_class(NULL, opline->op1.num);
9977
0
    if (UNEXPECTED(ce == NULL)) {
9978
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9979
0
      HANDLE_EXCEPTION();
9980
0
    }
9981
0
  } else {
9982
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
9983
0
  }
9984
9985
20
  if (IS_CONST == IS_CONST &&
9986
20
      (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9987
20
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
9988
    /* nothing to do */
9989
20
  } else if (IS_CONST != IS_CONST &&
9990
20
             (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9991
20
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
9992
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9993
20
  } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
9994
20
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9995
20
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9996
20
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9997
10
        do {
9998
10
          if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
9999
0
            function_name = Z_REFVAL_P(function_name);
10000
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
10001
0
              break;
10002
0
            }
10003
10
          } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
10004
0
            ZVAL_UNDEFINED_OP2();
10005
0
            if (UNEXPECTED(EG(exception) != NULL)) {
10006
0
              HANDLE_EXCEPTION();
10007
0
            }
10008
0
          }
10009
10
          zend_throw_error(NULL, "Method name must be a string");
10010
10
          zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10011
10
          HANDLE_EXCEPTION();
10012
10
        } while (0);
10013
10
      }
10014
20
    }
10015
10016
10
    if (ce->get_static_method) {
10017
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
10018
10
    } else {
10019
10
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
10020
10
    }
10021
10
    if (UNEXPECTED(fbc == NULL)) {
10022
0
      if (EXPECTED(!EG(exception))) {
10023
0
        zend_undefined_method(ce, Z_STR_P(function_name));
10024
0
      }
10025
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10026
0
      HANDLE_EXCEPTION();
10027
0
    }
10028
10
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
10029
10
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
10030
10
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
10031
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
10032
0
    }
10033
10
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10034
5
      init_func_run_time_cache(&fbc->op_array);
10035
5
    }
10036
10
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10037
10
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10038
10
    }
10039
10
  } else {
10040
0
    if (UNEXPECTED(ce->constructor == NULL)) {
10041
0
      zend_throw_error(NULL, "Cannot call constructor");
10042
0
      HANDLE_EXCEPTION();
10043
0
    }
10044
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
10045
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
10046
0
      HANDLE_EXCEPTION();
10047
0
    }
10048
0
    fbc = ce->constructor;
10049
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10050
0
      init_func_run_time_cache(&fbc->op_array);
10051
0
    }
10052
0
  }
10053
10054
10
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
10055
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
10056
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
10057
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
10058
0
    } else {
10059
0
      zend_non_static_method_call(fbc);
10060
0
      HANDLE_EXCEPTION();
10061
0
    }
10062
10
  } else {
10063
    /* previous opcode is ZEND_FETCH_CLASS */
10064
10
    if (IS_CONST == IS_UNUSED
10065
10
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
10066
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
10067
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
10068
0
        ce = Z_OBJCE(EX(This));
10069
0
      } else {
10070
0
        ce = Z_CE(EX(This));
10071
0
      }
10072
0
    }
10073
10
    call_info = ZEND_CALL_NESTED_FUNCTION;
10074
10
  }
10075
10076
10
  call = zend_vm_stack_push_call_frame(call_info,
10077
10
    fbc, opline->extended_value, ce);
10078
10
  call->prev_execute_data = EX(call);
10079
10
  EX(call) = call;
10080
10081
10
  ZEND_VM_NEXT_OPCODE();
10082
10
}
10083
10084
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10085
728
{
10086
728
  USE_OPLINE
10087
728
  zval *function_name;
10088
728
  zend_fcall_info_cache fcc;
10089
728
  char *error = NULL;
10090
728
  zend_function *func;
10091
728
  void *object_or_called_scope;
10092
728
  zend_execute_data *call;
10093
728
  uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
10094
10095
728
  SAVE_OPLINE();
10096
728
  function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10097
728
  if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
10098
668
    ZEND_ASSERT(!error);
10099
10100
    /* Deprecation can be emitted from zend_is_callable_ex(), which can
10101
     * invoke a user error handler and throw an exception.
10102
     * For the CONST and CV case we reuse the same exception block below
10103
     * to make sure we don't increase VM size too much. */
10104
668
    if (!((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
10105
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10106
0
      HANDLE_EXCEPTION();
10107
0
    }
10108
10109
668
    func = fcc.function_handler;
10110
668
    object_or_called_scope = fcc.called_scope;
10111
668
    if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
10112
      /* Delay closure destruction until its invocation */
10113
40
      GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
10114
40
      call_info |= ZEND_CALL_CLOSURE;
10115
40
      if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
10116
0
        call_info |= ZEND_CALL_FAKE_CLOSURE;
10117
0
      }
10118
40
      if (fcc.object) {
10119
5
        object_or_called_scope = fcc.object;
10120
5
        call_info |= ZEND_CALL_HAS_THIS;
10121
5
      }
10122
628
    } else if (fcc.object) {
10123
623
      GC_ADDREF(fcc.object); /* For $this pointer */
10124
623
      object_or_called_scope = fcc.object;
10125
623
      call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
10126
623
    }
10127
10128
668
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10129
668
    if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
10130
0
      if (call_info & ZEND_CALL_CLOSURE) {
10131
0
        zend_object_release(ZEND_CLOSURE_OBJECT(func));
10132
0
      } else if (call_info & ZEND_CALL_RELEASE_THIS) {
10133
0
        zend_object_release(fcc.object);
10134
0
      }
10135
0
      HANDLE_EXCEPTION();
10136
0
    }
10137
10138
668
    if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
10139
90
      init_func_run_time_cache(&func->op_array);
10140
90
    }
10141
668
  } else {
10142
60
    zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
10143
60
    efree(error);
10144
60
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10145
60
    HANDLE_EXCEPTION();
10146
60
  }
10147
10148
668
  call = zend_vm_stack_push_call_frame(call_info,
10149
668
    func, opline->extended_value, object_or_called_scope);
10150
668
  call->prev_execute_data = EX(call);
10151
668
  EX(call) = call;
10152
10153
668
  ZEND_VM_NEXT_OPCODE();
10154
668
}
10155
10156
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10157
430
{
10158
430
  USE_OPLINE
10159
430
  zval *expr_ptr, new_expr;
10160
10161
430
  SAVE_OPLINE();
10162
430
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
10163
430
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
10164
0
    expr_ptr = zend_get_bad_ptr();
10165
0
    if (Z_ISREF_P(expr_ptr)) {
10166
0
      Z_ADDREF_P(expr_ptr);
10167
0
    } else {
10168
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
10169
0
    }
10170
10171
430
  } else {
10172
430
    expr_ptr = RT_CONSTANT(opline, opline->op1);
10173
430
    if (IS_CONST == IS_TMP_VAR) {
10174
      /* pass */
10175
430
    } else if (IS_CONST == IS_CONST) {
10176
430
      Z_TRY_ADDREF_P(expr_ptr);
10177
430
    } else if (IS_CONST == IS_CV) {
10178
0
      ZVAL_DEREF(expr_ptr);
10179
0
      Z_TRY_ADDREF_P(expr_ptr);
10180
0
    } else /* if (IS_CONST == IS_VAR) */ {
10181
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
10182
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
10183
10184
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
10185
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
10186
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
10187
0
          expr_ptr = &new_expr;
10188
0
          efree_size(ref, sizeof(zend_reference));
10189
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
10190
0
          Z_ADDREF_P(expr_ptr);
10191
0
        }
10192
0
      }
10193
0
    }
10194
430
  }
10195
10196
430
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10197
430
    zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10198
430
    zend_string *str;
10199
430
    zend_ulong hval;
10200
10201
430
add_again:
10202
430
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10203
371
      str = Z_STR_P(offset);
10204
371
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10205
371
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
10206
3
          goto num_index;
10207
3
        }
10208
371
      }
10209
368
str_index:
10210
368
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
10211
368
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10212
49
      hval = Z_LVAL_P(offset);
10213
54
num_index:
10214
54
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
10215
54
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
10216
0
      offset = Z_REFVAL_P(offset);
10217
0
      goto add_again;
10218
10
    } else if (Z_TYPE_P(offset) == IS_NULL) {
10219
0
      str = ZSTR_EMPTY_ALLOC();
10220
0
      goto str_index;
10221
10
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
10222
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
10223
0
      goto num_index;
10224
10
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
10225
0
      hval = 0;
10226
0
      goto num_index;
10227
10
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
10228
2
      hval = 1;
10229
2
      goto num_index;
10230
8
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
10231
0
      zend_use_resource_as_offset(offset);
10232
0
      hval = Z_RES_HANDLE_P(offset);
10233
0
      goto num_index;
10234
8
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
10235
0
      ZVAL_UNDEFINED_OP2();
10236
0
      str = ZSTR_EMPTY_ALLOC();
10237
0
      goto str_index;
10238
8
    } else {
10239
8
      zend_illegal_array_offset_access(offset);
10240
8
      zval_ptr_dtor_nogc(expr_ptr);
10241
8
    }
10242
430
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10243
430
  } else {
10244
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
10245
0
      zend_cannot_add_element();
10246
0
      zval_ptr_dtor_nogc(expr_ptr);
10247
0
    }
10248
0
  }
10249
430
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10250
430
}
10251
10252
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10253
158
{
10254
158
  zval *array;
10255
158
  uint32_t size;
10256
158
  USE_OPLINE
10257
10258
158
  SAVE_OPLINE();
10259
158
  array = EX_VAR(opline->result.var);
10260
158
  if (IS_CONST != IS_UNUSED) {
10261
158
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
10262
158
    ZVAL_ARR(array, zend_new_array(size));
10263
    /* Explicitly initialize array as not-packed if flag is set */
10264
158
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
10265
58
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
10266
58
    }
10267
158
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10268
158
  } else {
10269
0
    ZVAL_ARR(array, zend_new_array(0));
10270
0
    ZEND_VM_NEXT_OPCODE();
10271
0
  }
10272
158
}
10273
10274
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10275
0
{
10276
0
  USE_OPLINE
10277
0
  zval *container;
10278
0
  bool result;
10279
0
  zend_ulong hval;
10280
0
  zval *offset;
10281
10282
0
  SAVE_OPLINE();
10283
0
  container = RT_CONSTANT(opline, opline->op1);
10284
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10285
10286
0
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
10287
0
    HashTable *ht;
10288
0
    zval *value;
10289
0
    zend_string *str;
10290
10291
0
isset_dim_obj_array:
10292
0
    ht = Z_ARRVAL_P(container);
10293
0
isset_again:
10294
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10295
0
      str = Z_STR_P(offset);
10296
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10297
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
10298
0
          goto num_index_prop;
10299
0
        }
10300
0
      }
10301
0
      value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
10302
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10303
0
      hval = Z_LVAL_P(offset);
10304
0
num_index_prop:
10305
0
      value = zend_hash_index_find(ht, hval);
10306
0
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
10307
0
      offset = Z_REFVAL_P(offset);
10308
0
      goto isset_again;
10309
0
    } else {
10310
0
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
10311
0
      if (UNEXPECTED(EG(exception))) {
10312
0
        result = 0;
10313
0
        goto isset_dim_obj_exit;
10314
0
      }
10315
0
    }
10316
10317
0
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
10318
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
10319
0
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
10320
0
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
10321
10322
0
      if (IS_CONST & (IS_CONST|IS_CV)) {
10323
        /* avoid exception check */
10324
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10325
0
        ZEND_VM_SMART_BRANCH(result, 0);
10326
0
      }
10327
0
    } else {
10328
0
      result = (value == NULL || !i_zend_is_true(value));
10329
0
    }
10330
0
    goto isset_dim_obj_exit;
10331
0
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
10332
0
    container = Z_REFVAL_P(container);
10333
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
10334
0
      goto isset_dim_obj_array;
10335
0
    }
10336
0
  }
10337
10338
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
10339
0
    offset++;
10340
0
  }
10341
0
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
10342
0
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
10343
0
  } else {
10344
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
10345
0
  }
10346
10347
0
isset_dim_obj_exit:
10348
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10349
10350
0
  ZEND_VM_SMART_BRANCH(result, 1);
10351
0
}
10352
10353
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10354
0
{
10355
0
  USE_OPLINE
10356
0
  zval *container;
10357
0
  int result;
10358
0
  zval *offset;
10359
0
  zend_string *name, *tmp_name;
10360
10361
0
  SAVE_OPLINE();
10362
0
  container = RT_CONSTANT(opline, opline->op1);
10363
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10364
10365
0
  if (IS_CONST == IS_CONST ||
10366
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
10367
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
10368
0
      container = Z_REFVAL_P(container);
10369
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
10370
0
        result = (opline->extended_value & ZEND_ISEMPTY);
10371
0
        goto isset_object_finish;
10372
0
      }
10373
0
    } else {
10374
0
      result = (opline->extended_value & ZEND_ISEMPTY);
10375
0
      goto isset_object_finish;
10376
0
    }
10377
0
  }
10378
10379
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
10380
0
    name = Z_STR_P(offset);
10381
0
  } else {
10382
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
10383
0
    if (UNEXPECTED(!name)) {
10384
0
      result = 0;
10385
0
      goto isset_object_finish;
10386
0
    }
10387
0
  }
10388
10389
0
  result =
10390
0
    (opline->extended_value & ZEND_ISEMPTY) ^
10391
0
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
10392
10393
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10394
0
    zend_tmp_string_release(tmp_name);
10395
0
  }
10396
10397
0
isset_object_finish:
10398
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10399
10400
0
  ZEND_VM_SMART_BRANCH(result, 1);
10401
0
}
10402
10403
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10404
9
{
10405
9
  USE_OPLINE
10406
10407
9
  zval *key, *subject;
10408
9
  HashTable *ht;
10409
9
  bool result;
10410
10411
9
  SAVE_OPLINE();
10412
10413
9
  key = RT_CONSTANT(opline, opline->op1);
10414
9
  subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10415
10416
9
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10417
0
array_key_exists_array:
10418
0
    ht = Z_ARRVAL_P(subject);
10419
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
10420
9
  } else {
10421
9
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
10422
0
      subject = Z_REFVAL_P(subject);
10423
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10424
0
        goto array_key_exists_array;
10425
0
      }
10426
0
    }
10427
9
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
10428
9
    result = 0;
10429
9
  }
10430
10431
9
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10432
10433
9
  ZEND_VM_SMART_BRANCH(result, 1);
10434
9
}
10435
10436
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10437
8
{
10438
8
  USE_OPLINE
10439
10440
8
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
10441
10442
8
  SAVE_OPLINE();
10443
8
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
10444
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10445
0
  }
10446
10447
  /* Destroy the previously yielded value */
10448
8
  zval_ptr_dtor(&generator->value);
10449
10450
  /* Destroy the previously yielded key */
10451
8
  zval_ptr_dtor(&generator->key);
10452
10453
  /* Set the new yielded value */
10454
8
  if (IS_CONST != IS_UNUSED) {
10455
8
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10456
      /* Constants and temporary variables aren't yieldable by reference,
10457
       * but we still allow them with a notice. */
10458
0
      if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
10459
0
        zval *value;
10460
10461
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10462
10463
0
        value = RT_CONSTANT(opline, opline->op1);
10464
0
        ZVAL_COPY_VALUE(&generator->value, value);
10465
0
        if (IS_CONST == IS_CONST) {
10466
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10467
0
            Z_ADDREF(generator->value);
10468
0
          }
10469
0
        }
10470
0
      } else {
10471
0
        zval *value_ptr = zend_get_bad_ptr();
10472
10473
        /* If a function call result is yielded and the function did
10474
         * not return by reference we throw a notice. */
10475
0
        do {
10476
0
          if (IS_CONST == IS_VAR) {
10477
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
10478
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
10479
0
             && !Z_ISREF_P(value_ptr)) {
10480
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10481
0
              ZVAL_COPY(&generator->value, value_ptr);
10482
0
              break;
10483
0
            }
10484
0
          }
10485
0
          if (Z_ISREF_P(value_ptr)) {
10486
0
            Z_ADDREF_P(value_ptr);
10487
0
          } else {
10488
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
10489
0
          }
10490
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
10491
0
        } while (0);
10492
10493
0
      }
10494
8
    } else {
10495
8
      zval *value = RT_CONSTANT(opline, opline->op1);
10496
10497
      /* Consts, temporary variables and references need copying */
10498
8
      if (IS_CONST == IS_CONST) {
10499
8
        ZVAL_COPY_VALUE(&generator->value, value);
10500
8
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10501
0
          Z_ADDREF(generator->value);
10502
0
        }
10503
8
      } else if (IS_CONST == IS_TMP_VAR) {
10504
0
        ZVAL_COPY_VALUE(&generator->value, value);
10505
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
10506
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
10507
10508
0
      } else {
10509
0
        ZVAL_COPY_VALUE(&generator->value, value);
10510
0
        if (IS_CONST == IS_CV) {
10511
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
10512
0
        }
10513
0
      }
10514
8
    }
10515
8
  } else {
10516
    /* If no value was specified yield null */
10517
0
    ZVAL_NULL(&generator->value);
10518
0
  }
10519
10520
  /* Set the new yielded key */
10521
8
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10522
8
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10523
8
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
10524
0
      key = Z_REFVAL_P(key);
10525
0
    }
10526
8
    ZVAL_COPY(&generator->key, key);
10527
8
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10528
10529
8
    if (Z_TYPE(generator->key) == IS_LONG
10530
8
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
10531
8
    ) {
10532
8
      generator->largest_used_integer_key = Z_LVAL(generator->key);
10533
8
    }
10534
8
  } else {
10535
    /* If no key was specified we use auto-increment keys */
10536
0
    generator->largest_used_integer_key++;
10537
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
10538
0
  }
10539
10540
8
  if (RETURN_VALUE_USED(opline)) {
10541
    /* If the return value of yield is used set the send
10542
     * target and initialize it to NULL */
10543
0
    generator->send_target = EX_VAR(opline->result.var);
10544
0
    ZVAL_NULL(generator->send_target);
10545
8
  } else {
10546
8
    generator->send_target = NULL;
10547
8
  }
10548
10549
  /* The GOTO VM uses a local opline variable. We need to set the opline
10550
   * variable in execute_data so we don't resume at an old position. */
10551
8
  SAVE_OPLINE();
10552
10553
8
  ZEND_VM_RETURN();
10554
8
}
10555
10556
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_EX int type)
10557
1.95k
{
10558
1.95k
  USE_OPLINE
10559
1.95k
  zval *varname;
10560
1.95k
  zval *retval;
10561
1.95k
  zend_string *name, *tmp_name;
10562
1.95k
  HashTable *target_symbol_table;
10563
10564
1.95k
  SAVE_OPLINE();
10565
1.95k
  varname = RT_CONSTANT(opline, opline->op1);
10566
10567
1.95k
  if (IS_CONST == IS_CONST) {
10568
1.95k
    name = Z_STR_P(varname);
10569
1.95k
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
10570
0
    name = Z_STR_P(varname);
10571
0
    tmp_name = NULL;
10572
0
  } else {
10573
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
10574
0
      ZVAL_UNDEFINED_OP1();
10575
0
    }
10576
0
    name = zval_try_get_tmp_string(varname, &tmp_name);
10577
0
    if (UNEXPECTED(!name)) {
10578
0
      if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10579
10580
0
      }
10581
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
10582
0
      HANDLE_EXCEPTION();
10583
0
    }
10584
0
  }
10585
10586
1.95k
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10587
1.95k
  retval = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
10588
1.95k
  if (retval == NULL) {
10589
330
    if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10590
0
fetch_this:
10591
0
      zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
10592
0
      if (IS_CONST != IS_CONST) {
10593
0
        zend_tmp_string_release(tmp_name);
10594
0
      }
10595
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10596
0
    }
10597
330
    if (type == BP_VAR_W) {
10598
45
      retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
10599
285
    } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10600
20
      retval = &EG(uninitialized_zval);
10601
265
    } else {
10602
265
      if (IS_CONST == IS_CV) {
10603
        /* Keep name alive in case an error handler tries to free it. */
10604
0
        zend_string_addref(name);
10605
0
      }
10606
265
      zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10607
265
        (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10608
265
      if (type == BP_VAR_RW && !EG(exception)) {
10609
0
        retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
10610
265
      } else {
10611
265
        retval = &EG(uninitialized_zval);
10612
265
      }
10613
265
      if (IS_CONST == IS_CV) {
10614
0
        zend_string_release(name);
10615
0
      }
10616
265
    }
10617
  /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
10618
1.62k
  } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
10619
1.28k
    retval = Z_INDIRECT_P(retval);
10620
1.28k
    if (Z_TYPE_P(retval) == IS_UNDEF) {
10621
134
      if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10622
0
        goto fetch_this;
10623
0
      }
10624
134
      if (type == BP_VAR_W) {
10625
59
        ZVAL_NULL(retval);
10626
75
      } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10627
0
        retval = &EG(uninitialized_zval);
10628
75
      } else {
10629
75
        zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10630
75
          (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10631
75
        if (type == BP_VAR_RW && !EG(exception)) {
10632
0
          ZVAL_NULL(retval);
10633
75
        } else {
10634
75
          retval = &EG(uninitialized_zval);
10635
75
        }
10636
75
      }
10637
134
    }
10638
1.28k
  }
10639
10640
1.95k
  if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10641
10642
1.95k
  }
10643
10644
1.95k
  if (IS_CONST != IS_CONST) {
10645
0
    zend_tmp_string_release(tmp_name);
10646
0
  }
10647
10648
1.95k
  ZEND_ASSERT(retval != NULL);
10649
1.95k
  if (type == BP_VAR_R || type == BP_VAR_IS) {
10650
654
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
10651
1.30k
  } else {
10652
1.30k
    ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
10653
1.30k
  }
10654
1.95k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10655
1.95k
}
10656
10657
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10658
639
{
10659
639
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R));
10660
639
}
10661
10662
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10663
1.25k
{
10664
1.25k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W));
10665
1.25k
}
10666
10667
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10668
23
{
10669
23
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW));
10670
23
}
10671
10672
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10673
0
{
10674
0
  int fetch_type =
10675
0
    (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
10676
0
      BP_VAR_W : BP_VAR_R;
10677
0
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type));
10678
0
}
10679
10680
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10681
23
{
10682
23
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET));
10683
23
}
10684
10685
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10686
15
{
10687
15
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS));
10688
15
}
10689
10690
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
10691
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10692
0
{
10693
#if 0
10694
  USE_OPLINE
10695
#endif
10696
10697
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
10698
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
10699
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10700
0
    }
10701
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10702
0
  } else {
10703
0
    if (IS_UNUSED == IS_UNUSED) {
10704
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10705
0
    }
10706
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10707
0
  }
10708
0
}
10709
10710
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10711
7
{
10712
7
  USE_OPLINE
10713
7
  zval *function_name;
10714
7
  zend_class_entry *ce;
10715
7
  uint32_t call_info;
10716
7
  zend_function *fbc;
10717
7
  zend_execute_data *call;
10718
10719
7
  SAVE_OPLINE();
10720
10721
7
  if (IS_CONST == IS_CONST) {
10722
    /* no function found. try a static method in class */
10723
7
    ce = CACHED_PTR(opline->result.num);
10724
7
    if (UNEXPECTED(ce == NULL)) {
10725
7
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
10726
7
      if (UNEXPECTED(ce == NULL)) {
10727
10728
2
        HANDLE_EXCEPTION();
10729
2
      }
10730
5
      if (IS_UNUSED != IS_CONST) {
10731
5
        CACHE_PTR(opline->result.num, ce);
10732
5
      }
10733
5
    }
10734
7
  } else if (IS_CONST == IS_UNUSED) {
10735
0
    ce = zend_fetch_class(NULL, opline->op1.num);
10736
0
    if (UNEXPECTED(ce == NULL)) {
10737
10738
0
      HANDLE_EXCEPTION();
10739
0
    }
10740
0
  } else {
10741
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
10742
0
  }
10743
10744
5
  if (IS_CONST == IS_CONST &&
10745
5
      IS_UNUSED == IS_CONST &&
10746
5
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
10747
    /* nothing to do */
10748
5
  } else if (IS_CONST != IS_CONST &&
10749
5
             IS_UNUSED == IS_CONST &&
10750
5
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
10751
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
10752
5
  } else if (IS_UNUSED != IS_UNUSED) {
10753
0
    function_name = NULL;
10754
0
    if (IS_UNUSED != IS_CONST) {
10755
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10756
0
        do {
10757
0
          if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
10758
0
            function_name = Z_REFVAL_P(function_name);
10759
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
10760
0
              break;
10761
0
            }
10762
0
          } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
10763
0
            ZVAL_UNDEFINED_OP2();
10764
0
            if (UNEXPECTED(EG(exception) != NULL)) {
10765
0
              HANDLE_EXCEPTION();
10766
0
            }
10767
0
          }
10768
0
          zend_throw_error(NULL, "Method name must be a string");
10769
10770
0
          HANDLE_EXCEPTION();
10771
0
        } while (0);
10772
0
      }
10773
0
    }
10774
10775
0
    if (ce->get_static_method) {
10776
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
10777
0
    } else {
10778
0
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
10779
0
    }
10780
0
    if (UNEXPECTED(fbc == NULL)) {
10781
0
      if (EXPECTED(!EG(exception))) {
10782
0
        zend_undefined_method(ce, Z_STR_P(function_name));
10783
0
      }
10784
10785
0
      HANDLE_EXCEPTION();
10786
0
    }
10787
0
    if (IS_UNUSED == IS_CONST &&
10788
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
10789
0
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
10790
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
10791
0
    }
10792
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10793
0
      init_func_run_time_cache(&fbc->op_array);
10794
0
    }
10795
0
    if (IS_UNUSED != IS_CONST) {
10796
10797
0
    }
10798
5
  } else {
10799
5
    if (UNEXPECTED(ce->constructor == NULL)) {
10800
5
      zend_throw_error(NULL, "Cannot call constructor");
10801
5
      HANDLE_EXCEPTION();
10802
5
    }
10803
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
10804
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
10805
0
      HANDLE_EXCEPTION();
10806
0
    }
10807
0
    fbc = ce->constructor;
10808
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10809
0
      init_func_run_time_cache(&fbc->op_array);
10810
0
    }
10811
0
  }
10812
10813
0
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
10814
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
10815
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
10816
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
10817
0
    } else {
10818
0
      zend_non_static_method_call(fbc);
10819
0
      HANDLE_EXCEPTION();
10820
0
    }
10821
0
  } else {
10822
    /* previous opcode is ZEND_FETCH_CLASS */
10823
0
    if (IS_CONST == IS_UNUSED
10824
0
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
10825
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
10826
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
10827
0
        ce = Z_OBJCE(EX(This));
10828
0
      } else {
10829
0
        ce = Z_CE(EX(This));
10830
0
      }
10831
0
    }
10832
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
10833
0
  }
10834
10835
0
  call = zend_vm_stack_push_call_frame(call_info,
10836
0
    fbc, opline->extended_value, ce);
10837
0
  call->prev_execute_data = EX(call);
10838
0
  EX(call) = call;
10839
10840
0
  ZEND_VM_NEXT_OPCODE();
10841
0
}
10842
10843
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10844
128
{
10845
128
  if (IS_CONST == IS_UNUSED) {
10846
0
    SAVE_OPLINE();
10847
0
    zend_verify_missing_return_type(EX(func));
10848
0
    HANDLE_EXCEPTION();
10849
128
  } else {
10850
/* prevents "undefined variable opline" errors */
10851
128
#if 0 || (IS_CONST != IS_UNUSED)
10852
128
    USE_OPLINE
10853
128
    zval *retval_ref, *retval_ptr;
10854
128
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
10855
128
    retval_ref = retval_ptr = RT_CONSTANT(opline, opline->op1);
10856
10857
128
    if (IS_CONST == IS_CONST) {
10858
128
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
10859
128
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
10860
128
    } else if (IS_CONST == IS_VAR) {
10861
0
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
10862
0
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
10863
0
      }
10864
0
      ZVAL_DEREF(retval_ptr);
10865
0
    } else if (IS_CONST == IS_CV) {
10866
0
      ZVAL_DEREF(retval_ptr);
10867
0
    }
10868
10869
128
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
10870
0
      ZEND_VM_NEXT_OPCODE();
10871
0
    }
10872
10873
128
    if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
10874
0
      SAVE_OPLINE();
10875
0
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
10876
0
      if (UNEXPECTED(EG(exception))) {
10877
0
        HANDLE_EXCEPTION();
10878
0
      }
10879
0
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
10880
0
        ZEND_VM_NEXT_OPCODE();
10881
0
      }
10882
0
    }
10883
10884
128
    zend_reference *ref = NULL;
10885
128
    if (UNEXPECTED(retval_ref != retval_ptr)) {
10886
0
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10887
0
        ref = Z_REF_P(retval_ref);
10888
0
      } else {
10889
        /* A cast might happen - unwrap the reference if this is a by-value return */
10890
0
        if (Z_REFCOUNT_P(retval_ref) == 1) {
10891
0
          ZVAL_UNREF(retval_ref);
10892
0
        } else {
10893
0
          Z_DELREF_P(retval_ref);
10894
0
          ZVAL_COPY(retval_ref, retval_ptr);
10895
0
        }
10896
0
        retval_ptr = retval_ref;
10897
0
      }
10898
0
    }
10899
10900
128
    SAVE_OPLINE();
10901
128
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
10902
98
      zend_verify_return_error(EX(func), retval_ptr);
10903
98
      HANDLE_EXCEPTION();
10904
98
    }
10905
30
    ZEND_VM_NEXT_OPCODE();
10906
30
#endif
10907
30
  }
10908
128
}
10909
10910
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10911
2.76k
{
10912
2.76k
  USE_OPLINE
10913
2.76k
  zval *value, *arg;
10914
10915
2.76k
  if (IS_UNUSED == IS_CONST) {
10916
0
    SAVE_OPLINE();
10917
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10918
0
    uint32_t arg_num;
10919
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10920
0
    if (UNEXPECTED(!arg)) {
10921
10922
0
      HANDLE_EXCEPTION();
10923
0
    }
10924
2.76k
  } else {
10925
2.76k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10926
2.76k
  }
10927
10928
2.76k
  value = RT_CONSTANT(opline, opline->op1);
10929
2.76k
  ZVAL_COPY_VALUE(arg, value);
10930
2.76k
  if (IS_CONST == IS_CONST) {
10931
2.76k
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10932
51
      Z_ADDREF_P(arg);
10933
51
    }
10934
2.76k
  }
10935
2.76k
  ZEND_VM_NEXT_OPCODE();
10936
2.76k
}
10937
10938
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10939
0
{
10940
0
  USE_OPLINE
10941
0
  zval *value, *arg;
10942
0
  uint32_t arg_num;
10943
10944
0
  if (IS_UNUSED == IS_CONST) {
10945
0
    SAVE_OPLINE();
10946
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10947
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10948
0
    if (UNEXPECTED(!arg)) {
10949
10950
0
      HANDLE_EXCEPTION();
10951
0
    }
10952
0
  } else {
10953
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10954
0
    arg_num = opline->op2.num;
10955
0
  }
10956
10957
0
  if (EXPECTED(0)) {
10958
0
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10959
0
      goto send_val_by_ref;
10960
0
    }
10961
0
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10962
0
send_val_by_ref:
10963
0
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
10964
0
  }
10965
0
  value = RT_CONSTANT(opline, opline->op1);
10966
0
  ZVAL_COPY_VALUE(arg, value);
10967
0
  if (IS_CONST == IS_CONST) {
10968
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10969
0
      Z_ADDREF_P(arg);
10970
0
    }
10971
0
  }
10972
0
  ZEND_VM_NEXT_OPCODE();
10973
0
}
10974
10975
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10976
525
{
10977
525
  USE_OPLINE
10978
525
  zval *value, *arg;
10979
525
  uint32_t arg_num;
10980
10981
525
  if (IS_UNUSED == IS_CONST) {
10982
0
    SAVE_OPLINE();
10983
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10984
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10985
0
    if (UNEXPECTED(!arg)) {
10986
10987
0
      HANDLE_EXCEPTION();
10988
0
    }
10989
525
  } else {
10990
525
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10991
525
    arg_num = opline->op2.num;
10992
525
  }
10993
10994
525
  if (EXPECTED(1)) {
10995
525
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10996
0
      goto send_val_by_ref;
10997
0
    }
10998
525
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10999
0
send_val_by_ref:
11000
0
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
11001
0
  }
11002
525
  value = RT_CONSTANT(opline, opline->op1);
11003
525
  ZVAL_COPY_VALUE(arg, value);
11004
525
  if (IS_CONST == IS_CONST) {
11005
525
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
11006
5
      Z_ADDREF_P(arg);
11007
5
    }
11008
525
  }
11009
525
  ZEND_VM_NEXT_OPCODE();
11010
525
}
11011
11012
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11013
1.03M
{
11014
1.03M
  USE_OPLINE
11015
1.03M
  zval *result;
11016
1.03M
  zend_function *constructor;
11017
1.03M
  zend_class_entry *ce;
11018
1.03M
  zend_execute_data *call;
11019
11020
1.03M
  SAVE_OPLINE();
11021
1.03M
  if (IS_CONST == IS_CONST) {
11022
1.03M
    ce = CACHED_PTR(opline->op2.num);
11023
1.03M
    if (UNEXPECTED(ce == NULL)) {
11024
221k
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
11025
221k
      if (UNEXPECTED(ce == NULL)) {
11026
1.63k
        ZVAL_UNDEF(EX_VAR(opline->result.var));
11027
1.63k
        HANDLE_EXCEPTION();
11028
1.63k
      }
11029
220k
      CACHE_PTR(opline->op2.num, ce);
11030
220k
    }
11031
1.03M
  } else if (IS_CONST == IS_UNUSED) {
11032
0
    ce = zend_fetch_class(NULL, opline->op1.num);
11033
0
    if (UNEXPECTED(ce == NULL)) {
11034
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
11035
0
      HANDLE_EXCEPTION();
11036
0
    }
11037
0
  } else {
11038
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
11039
0
  }
11040
11041
1.03M
  result = EX_VAR(opline->result.var);
11042
1.03M
  if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
11043
94
    ZVAL_UNDEF(result);
11044
94
    HANDLE_EXCEPTION();
11045
94
  }
11046
11047
1.02M
  constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
11048
1.02M
  if (constructor == NULL) {
11049
    /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
11050
     * opcode is DO_FCALL in case EXT instructions are used. */
11051
316k
    if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
11052
315k
      ZEND_VM_NEXT_OPCODE_EX(1, 2);
11053
315k
    }
11054
11055
173
    if (UNEXPECTED(EG(exception))) {
11056
5
      HANDLE_EXCEPTION();
11057
5
    }
11058
11059
    /* Perform a dummy function call */
11060
168
    call = zend_vm_stack_push_call_frame(
11061
168
      ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
11062
168
      opline->extended_value, NULL);
11063
713k
  } else {
11064
713k
    if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
11065
2.06k
      init_func_run_time_cache(&constructor->op_array);
11066
2.06k
    }
11067
    /* We are not handling overloaded classes right now */
11068
713k
    call = zend_vm_stack_push_call_frame(
11069
713k
      ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
11070
713k
      constructor,
11071
713k
      opline->extended_value,
11072
713k
      Z_OBJ_P(result));
11073
713k
    Z_ADDREF_P(result);
11074
713k
  }
11075
11076
714k
  call->prev_execute_data = EX(call);
11077
714k
  EX(call) = call;
11078
714k
  ZEND_VM_NEXT_OPCODE();
11079
714k
}
11080
11081
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11082
41.8k
{
11083
41.8k
  USE_OPLINE
11084
41.8k
  zval *expr_ptr, new_expr;
11085
11086
41.8k
  SAVE_OPLINE();
11087
41.8k
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
11088
41.8k
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
11089
0
    expr_ptr = zend_get_bad_ptr();
11090
0
    if (Z_ISREF_P(expr_ptr)) {
11091
0
      Z_ADDREF_P(expr_ptr);
11092
0
    } else {
11093
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
11094
0
    }
11095
11096
41.8k
  } else {
11097
41.8k
    expr_ptr = RT_CONSTANT(opline, opline->op1);
11098
41.8k
    if (IS_CONST == IS_TMP_VAR) {
11099
      /* pass */
11100
41.8k
    } else if (IS_CONST == IS_CONST) {
11101
41.8k
      Z_TRY_ADDREF_P(expr_ptr);
11102
41.8k
    } else if (IS_CONST == IS_CV) {
11103
0
      ZVAL_DEREF(expr_ptr);
11104
0
      Z_TRY_ADDREF_P(expr_ptr);
11105
0
    } else /* if (IS_CONST == IS_VAR) */ {
11106
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
11107
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
11108
11109
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
11110
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
11111
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
11112
0
          expr_ptr = &new_expr;
11113
0
          efree_size(ref, sizeof(zend_reference));
11114
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
11115
0
          Z_ADDREF_P(expr_ptr);
11116
0
        }
11117
0
      }
11118
0
    }
11119
41.8k
  }
11120
11121
41.8k
  if (IS_UNUSED != IS_UNUSED) {
11122
0
    zval *offset = NULL;
11123
0
    zend_string *str;
11124
0
    zend_ulong hval;
11125
11126
0
add_again:
11127
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
11128
0
      str = Z_STR_P(offset);
11129
0
      if (IS_UNUSED != IS_CONST) {
11130
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
11131
0
          goto num_index;
11132
0
        }
11133
0
      }
11134
0
str_index:
11135
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
11136
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
11137
0
      hval = Z_LVAL_P(offset);
11138
0
num_index:
11139
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
11140
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
11141
0
      offset = Z_REFVAL_P(offset);
11142
0
      goto add_again;
11143
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
11144
0
      str = ZSTR_EMPTY_ALLOC();
11145
0
      goto str_index;
11146
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
11147
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
11148
0
      goto num_index;
11149
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
11150
0
      hval = 0;
11151
0
      goto num_index;
11152
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
11153
0
      hval = 1;
11154
0
      goto num_index;
11155
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
11156
0
      zend_use_resource_as_offset(offset);
11157
0
      hval = Z_RES_HANDLE_P(offset);
11158
0
      goto num_index;
11159
0
    } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
11160
0
      ZVAL_UNDEFINED_OP2();
11161
0
      str = ZSTR_EMPTY_ALLOC();
11162
0
      goto str_index;
11163
0
    } else {
11164
0
      zend_illegal_array_offset_access(offset);
11165
0
      zval_ptr_dtor_nogc(expr_ptr);
11166
0
    }
11167
11168
41.8k
  } else {
11169
41.8k
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
11170
20
      zend_cannot_add_element();
11171
20
      zval_ptr_dtor_nogc(expr_ptr);
11172
20
    }
11173
41.8k
  }
11174
41.8k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11175
41.8k
}
11176
11177
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11178
2.09k
{
11179
2.09k
  zval *array;
11180
2.09k
  uint32_t size;
11181
2.09k
  USE_OPLINE
11182
11183
2.09k
  SAVE_OPLINE();
11184
2.09k
  array = EX_VAR(opline->result.var);
11185
2.09k
  if (IS_CONST != IS_UNUSED) {
11186
2.09k
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
11187
2.09k
    ZVAL_ARR(array, zend_new_array(size));
11188
    /* Explicitly initialize array as not-packed if flag is set */
11189
2.09k
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
11190
22
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
11191
22
    }
11192
2.09k
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11193
2.09k
  } else {
11194
0
    ZVAL_ARR(array, zend_new_array(0));
11195
0
    ZEND_VM_NEXT_OPCODE();
11196
0
  }
11197
2.09k
}
11198
11199
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11200
309
{
11201
309
  USE_OPLINE
11202
309
  zval *varname;
11203
309
  zend_string *name, *tmp_name;
11204
309
  HashTable *target_symbol_table;
11205
11206
309
  SAVE_OPLINE();
11207
11208
309
  varname = RT_CONSTANT(opline, opline->op1);
11209
11210
309
  if (IS_CONST == IS_CONST) {
11211
309
    name = Z_STR_P(varname);
11212
309
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
11213
0
    name = Z_STR_P(varname);
11214
0
    tmp_name = NULL;
11215
0
  } else {
11216
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
11217
0
      varname = ZVAL_UNDEFINED_OP1();
11218
0
    }
11219
0
    name = zval_try_get_tmp_string(varname, &tmp_name);
11220
0
    if (UNEXPECTED(!name)) {
11221
11222
0
      HANDLE_EXCEPTION();
11223
0
    }
11224
0
  }
11225
11226
309
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
11227
309
  zend_hash_del_ind(target_symbol_table, name);
11228
11229
309
  if (IS_CONST != IS_CONST) {
11230
0
    zend_tmp_string_release(tmp_name);
11231
0
  }
11232
11233
309
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11234
309
}
11235
11236
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
11237
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11238
82
{
11239
82
  USE_OPLINE
11240
82
  zval *value;
11241
82
  bool result;
11242
82
  zval *varname;
11243
82
  zend_string *name, *tmp_name;
11244
82
  HashTable *target_symbol_table;
11245
11246
82
  SAVE_OPLINE();
11247
82
  varname = RT_CONSTANT(opline, opline->op1);
11248
82
  if (IS_CONST == IS_CONST) {
11249
82
    name = Z_STR_P(varname);
11250
82
  } else {
11251
0
    name = zval_get_tmp_string(varname, &tmp_name);
11252
0
  }
11253
11254
82
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
11255
82
  value = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
11256
11257
82
  if (IS_CONST != IS_CONST) {
11258
0
    zend_tmp_string_release(tmp_name);
11259
0
  }
11260
11261
82
  if (!value) {
11262
12
    result = (opline->extended_value & ZEND_ISEMPTY);
11263
70
  } else {
11264
70
    if (Z_TYPE_P(value) == IS_INDIRECT) {
11265
17
      value = Z_INDIRECT_P(value);
11266
17
    }
11267
70
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
11268
43
      if (Z_ISREF_P(value)) {
11269
0
        value = Z_REFVAL_P(value);
11270
0
      }
11271
43
      result = Z_TYPE_P(value) > IS_NULL;
11272
43
    } else {
11273
27
      result = !i_zend_is_true(value);
11274
27
    }
11275
70
  }
11276
11277
82
  ZEND_VM_SMART_BRANCH(result, true);
11278
82
}
11279
11280
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
11281
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11282
791
{
11283
791
  USE_OPLINE
11284
11285
791
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
11286
11287
791
  SAVE_OPLINE();
11288
791
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
11289
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11290
0
  }
11291
11292
  /* Destroy the previously yielded value */
11293
791
  zval_ptr_dtor(&generator->value);
11294
11295
  /* Destroy the previously yielded key */
11296
791
  zval_ptr_dtor(&generator->key);
11297
11298
  /* Set the new yielded value */
11299
791
  if (IS_CONST != IS_UNUSED) {
11300
791
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
11301
      /* Constants and temporary variables aren't yieldable by reference,
11302
       * but we still allow them with a notice. */
11303
5
      if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
11304
5
        zval *value;
11305
11306
5
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11307
11308
5
        value = RT_CONSTANT(opline, opline->op1);
11309
5
        ZVAL_COPY_VALUE(&generator->value, value);
11310
5
        if (IS_CONST == IS_CONST) {
11311
5
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
11312
0
            Z_ADDREF(generator->value);
11313
0
          }
11314
5
        }
11315
5
      } else {
11316
0
        zval *value_ptr = zend_get_bad_ptr();
11317
11318
        /* If a function call result is yielded and the function did
11319
         * not return by reference we throw a notice. */
11320
0
        do {
11321
0
          if (IS_CONST == IS_VAR) {
11322
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
11323
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
11324
0
             && !Z_ISREF_P(value_ptr)) {
11325
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11326
0
              ZVAL_COPY(&generator->value, value_ptr);
11327
0
              break;
11328
0
            }
11329
0
          }
11330
0
          if (Z_ISREF_P(value_ptr)) {
11331
0
            Z_ADDREF_P(value_ptr);
11332
0
          } else {
11333
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
11334
0
          }
11335
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
11336
0
        } while (0);
11337
11338
0
      }
11339
786
    } else {
11340
786
      zval *value = RT_CONSTANT(opline, opline->op1);
11341
11342
      /* Consts, temporary variables and references need copying */
11343
786
      if (IS_CONST == IS_CONST) {
11344
786
        ZVAL_COPY_VALUE(&generator->value, value);
11345
786
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
11346
0
          Z_ADDREF(generator->value);
11347
0
        }
11348
786
      } else if (IS_CONST == IS_TMP_VAR) {
11349
0
        ZVAL_COPY_VALUE(&generator->value, value);
11350
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
11351
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
11352
11353
0
      } else {
11354
0
        ZVAL_COPY_VALUE(&generator->value, value);
11355
0
        if (IS_CONST == IS_CV) {
11356
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
11357
0
        }
11358
0
      }
11359
786
    }
11360
791
  } else {
11361
    /* If no value was specified yield null */
11362
0
    ZVAL_NULL(&generator->value);
11363
0
  }
11364
11365
  /* Set the new yielded key */
11366
791
  if (IS_UNUSED != IS_UNUSED) {
11367
0
    zval *key = NULL;
11368
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
11369
0
      key = Z_REFVAL_P(key);
11370
0
    }
11371
0
    ZVAL_COPY(&generator->key, key);
11372
11373
0
    if (Z_TYPE(generator->key) == IS_LONG
11374
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
11375
0
    ) {
11376
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
11377
0
    }
11378
791
  } else {
11379
    /* If no key was specified we use auto-increment keys */
11380
791
    generator->largest_used_integer_key++;
11381
791
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
11382
791
  }
11383
11384
791
  if (RETURN_VALUE_USED(opline)) {
11385
    /* If the return value of yield is used set the send
11386
     * target and initialize it to NULL */
11387
65
    generator->send_target = EX_VAR(opline->result.var);
11388
65
    ZVAL_NULL(generator->send_target);
11389
726
  } else {
11390
726
    generator->send_target = NULL;
11391
726
  }
11392
11393
  /* The GOTO VM uses a local opline variable. We need to set the opline
11394
   * variable in execute_data so we don't resume at an old position. */
11395
791
  SAVE_OPLINE();
11396
11397
791
  ZEND_VM_RETURN();
11398
791
}
11399
11400
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11401
45
{
11402
45
  USE_OPLINE
11403
45
  zval *op;
11404
11405
45
  SAVE_OPLINE();
11406
45
  op = RT_CONSTANT(opline, opline->op1);
11407
45
  zend_match_unhandled_error(op);
11408
45
  HANDLE_EXCEPTION();
11409
45
}
11410
11411
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11412
2
{
11413
2
  USE_OPLINE
11414
2
  zval *op1;
11415
2
  zend_long count;
11416
11417
2
  SAVE_OPLINE();
11418
2
  op1 = RT_CONSTANT(opline, opline->op1);
11419
11420
2
  while (1) {
11421
2
    if (Z_TYPE_P(op1) == IS_ARRAY) {
11422
0
      count = zend_hash_num_elements(Z_ARRVAL_P(op1));
11423
0
      break;
11424
2
    } else if (Z_TYPE_P(op1) == IS_OBJECT) {
11425
0
      zend_object *zobj = Z_OBJ_P(op1);
11426
11427
      /* first, we check if the handler is defined */
11428
0
      if (zobj->handlers->count_elements) {
11429
0
        if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
11430
0
          break;
11431
0
        }
11432
0
        if (UNEXPECTED(EG(exception))) {
11433
0
          count = 0;
11434
0
          break;
11435
0
        }
11436
0
      }
11437
11438
      /* if not and the object implements Countable we call its count() method */
11439
0
      if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
11440
0
        zval retval;
11441
11442
0
        zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
11443
0
        zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
11444
0
        count = zval_get_long(&retval);
11445
0
        zval_ptr_dtor(&retval);
11446
0
        break;
11447
0
      }
11448
11449
      /* If There's no handler and it doesn't implement Countable then emit a TypeError */
11450
2
    } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11451
0
      op1 = Z_REFVAL_P(op1);
11452
0
      continue;
11453
2
    } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11454
0
      ZVAL_UNDEFINED_OP1();
11455
0
    }
11456
2
    count = 0;
11457
2
    zend_type_error("%s(): Argument #1 ($value) must be of type Countable|array, %s given", opline->extended_value ? "sizeof" : "count", zend_zval_value_name(op1));
11458
2
    break;
11459
2
  }
11460
11461
2
  ZVAL_LONG(EX_VAR(opline->result.var), count);
11462
11463
2
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11464
2
}
11465
11466
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11467
16
{
11468
16
  USE_OPLINE
11469
11470
16
  if (IS_CONST == IS_UNUSED) {
11471
0
    SAVE_OPLINE();
11472
0
    if (UNEXPECTED(!EX(func)->common.scope)) {
11473
0
      zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
11474
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
11475
0
      HANDLE_EXCEPTION();
11476
0
    } else {
11477
0
      zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
11478
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
11479
0
      if (UNEXPECTED(EG(exception))) {
11480
0
        HANDLE_EXCEPTION();
11481
0
      }
11482
0
      ZEND_VM_NEXT_OPCODE();
11483
0
    }
11484
16
  } else {
11485
16
    zval *op1;
11486
11487
16
    SAVE_OPLINE();
11488
16
    op1 = RT_CONSTANT(opline, opline->op1);
11489
16
    while (1) {
11490
16
      if (Z_TYPE_P(op1) == IS_OBJECT) {
11491
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
11492
16
      } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11493
0
        op1 = Z_REFVAL_P(op1);
11494
0
        continue;
11495
16
      } else {
11496
16
        if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11497
0
          ZVAL_UNDEFINED_OP1();
11498
0
        }
11499
16
        zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
11500
16
        ZVAL_UNDEF(EX_VAR(opline->result.var));
11501
16
      }
11502
16
      break;
11503
16
    }
11504
11505
16
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11506
16
  }
11507
16
}
11508
11509
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11510
0
{
11511
0
  USE_OPLINE
11512
0
  zval *op1;
11513
0
  zend_string *type;
11514
11515
0
  SAVE_OPLINE();
11516
0
  op1 = RT_CONSTANT(opline, opline->op1);
11517
0
  type = zend_zval_get_legacy_type(op1);
11518
0
  if (EXPECTED(type)) {
11519
0
    ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
11520
0
  } else {
11521
0
    ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
11522
0
  }
11523
11524
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11525
0
}
11526
11527
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11528
21
{
11529
21
  USE_OPLINE
11530
21
  zend_array *ht;
11531
21
  uint32_t arg_count, result_size, skip;
11532
11533
21
  arg_count = EX_NUM_ARGS();
11534
21
  if (IS_CONST == IS_CONST) {
11535
21
    skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
11536
21
    if (arg_count < skip) {
11537
5
      result_size = 0;
11538
16
    } else {
11539
16
      result_size = arg_count - skip;
11540
16
    }
11541
21
  } else {
11542
0
    skip = 0;
11543
0
    result_size = arg_count;
11544
0
  }
11545
11546
21
  if (result_size) {
11547
16
    SAVE_OPLINE();
11548
16
    uint32_t first_extra_arg = EX(func)->op_array.num_args;
11549
11550
16
    ht = zend_new_array(result_size);
11551
16
    ZVAL_ARR(EX_VAR(opline->result.var), ht);
11552
16
    zend_hash_real_init_packed(ht);
11553
16
    ZEND_HASH_FILL_PACKED(ht) {
11554
16
      zval *p, *q;
11555
16
      uint32_t i = skip;
11556
16
      p = EX_VAR_NUM(i);
11557
16
      if (arg_count > first_extra_arg) {
11558
16
        while (i < first_extra_arg) {
11559
0
          q = p;
11560
0
          if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11561
0
            ZVAL_DEREF(q);
11562
0
            if (Z_OPT_REFCOUNTED_P(q)) {
11563
0
              Z_ADDREF_P(q);
11564
0
            }
11565
0
            ZEND_HASH_FILL_SET(q);
11566
0
          } else {
11567
0
            ZEND_HASH_FILL_SET_NULL();
11568
0
          }
11569
0
          ZEND_HASH_FILL_NEXT();
11570
0
          p++;
11571
0
          i++;
11572
0
        }
11573
16
        if (skip < first_extra_arg) {
11574
0
          skip = 0;
11575
16
        } else {
11576
16
          skip -= first_extra_arg;
11577
16
        }
11578
16
        p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
11579
16
      }
11580
48
      while (i < arg_count) {
11581
32
        q = p;
11582
32
        if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11583
32
          ZVAL_DEREF(q);
11584
32
          if (Z_OPT_REFCOUNTED_P(q)) {
11585
0
            Z_ADDREF_P(q);
11586
0
          }
11587
32
          ZEND_HASH_FILL_SET(q);
11588
32
        } else {
11589
0
          ZEND_HASH_FILL_SET_NULL();
11590
0
        }
11591
32
        ZEND_HASH_FILL_NEXT();
11592
32
        p++;
11593
32
        i++;
11594
32
      }
11595
16
    } ZEND_HASH_FILL_END();
11596
16
    ht->nNumOfElements = result_size;
11597
16
  } else {
11598
5
    ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
11599
5
  }
11600
21
  ZEND_VM_NEXT_OPCODE();
11601
21
}
11602
11603
/* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
11604
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11605
293
{
11606
293
  USE_OPLINE
11607
293
  SAVE_OPLINE();
11608
11609
293
  zend_class_entry *ce = EX(func)->common.scope;
11610
293
  ZEND_ASSERT(ce);
11611
11612
293
  zend_class_entry *parent_ce = ce->parent;
11613
293
  if (!parent_ce) {
11614
5
    zend_throw_error(NULL, "Cannot use \"parent\" when current class scope has no parent");
11615
5
    UNDEF_RESULT();
11616
5
    HANDLE_EXCEPTION();
11617
5
  }
11618
11619
288
  zend_string *property_name = Z_STR_P(RT_CONSTANT(opline, opline->op1));
11620
288
  zend_property_hook_kind hook_kind = opline->op2.num;
11621
11622
288
  zend_property_info *prop_info = zend_hash_find_ptr(&parent_ce->properties_info, property_name);
11623
288
  if (!prop_info) {
11624
7
    zend_throw_error(NULL, "Undefined property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name));
11625
7
    UNDEF_RESULT();
11626
7
    HANDLE_EXCEPTION();
11627
7
  }
11628
281
  if (prop_info->flags & ZEND_ACC_PRIVATE) {
11629
5
    zend_throw_error(NULL, "Cannot access private property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name));
11630
5
    UNDEF_RESULT();
11631
5
    HANDLE_EXCEPTION();
11632
5
  }
11633
11634
276
  zend_function **hooks = prop_info->hooks;
11635
276
  zend_function *hook = hooks ? hooks[hook_kind] : NULL;
11636
11637
276
  zend_execute_data *call;
11638
276
  if (hook) {
11639
60
    call = zend_vm_stack_push_call_frame(
11640
60
      ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS,
11641
60
      hook, opline->extended_value, Z_OBJ_P(ZEND_THIS));
11642
60
    if (EXPECTED(hook->type == ZEND_USER_FUNCTION)) {
11643
60
      if (UNEXPECTED(!RUN_TIME_CACHE(&hook->op_array))) {
11644
23
        init_func_run_time_cache(&hook->op_array);
11645
23
      }
11646
60
      call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
11647
60
    }
11648
216
  } else {
11649
216
    zend_function *fbc = zend_get_property_hook_trampoline(prop_info, hook_kind, property_name);
11650
216
    call = zend_vm_stack_push_call_frame(
11651
216
      ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS,
11652
216
      fbc, opline->extended_value, Z_OBJ_P(ZEND_THIS));
11653
216
  }
11654
11655
276
  call->prev_execute_data = EX(call);
11656
276
  EX(call) = call;
11657
276
  ZEND_VM_NEXT_OPCODE();
11658
276
}
11659
11660
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11661
43
{
11662
43
  USE_OPLINE
11663
43
  zval *op1, *op2;
11664
11665
43
  SAVE_OPLINE();
11666
43
  op1 = RT_CONSTANT(opline, opline->op1);
11667
43
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11668
43
  div_function(EX_VAR(opline->result.var), op1, op2);
11669
11670
11671
43
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11672
43
}
11673
11674
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11675
0
{
11676
0
  USE_OPLINE
11677
0
  zval *op1, *op2;
11678
11679
0
  SAVE_OPLINE();
11680
0
  op1 = RT_CONSTANT(opline, opline->op1);
11681
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11682
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
11683
11684
11685
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11686
0
}
11687
11688
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11689
8.76k
{
11690
8.76k
  USE_OPLINE
11691
8.76k
  zval *op1, *op2;
11692
11693
8.76k
  op1 = RT_CONSTANT(opline, opline->op1);
11694
8.76k
  op2 = EX_VAR(opline->op2.var);
11695
11696
8.76k
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
11697
8.76k
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
11698
571
    zend_string *op1_str = Z_STR_P(op1);
11699
571
    zend_string *op2_str = Z_STR_P(op2);
11700
571
    zend_string *str;
11701
571
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
11702
11703
571
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11704
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
11705
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
11706
0
      } else {
11707
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11708
0
      }
11709
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11710
0
        zend_string_release_ex(op1_str, 0);
11711
0
      }
11712
571
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11713
1
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
11714
1
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
11715
1
      } else {
11716
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11717
0
      }
11718
1
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11719
0
        zend_string_release_ex(op2_str, 0);
11720
0
      }
11721
570
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
11722
570
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
11723
0
      size_t len = ZSTR_LEN(op1_str);
11724
11725
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
11726
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
11727
0
      }
11728
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
11729
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11730
0
      GC_ADD_FLAGS(str, flags);
11731
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11732
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11733
0
        zend_string_release_ex(op2_str, 0);
11734
0
      }
11735
570
    } else {
11736
570
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11737
570
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11738
570
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11739
570
      GC_ADD_FLAGS(str, flags);
11740
570
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11741
570
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11742
0
        zend_string_release_ex(op1_str, 0);
11743
0
      }
11744
570
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11745
0
        zend_string_release_ex(op2_str, 0);
11746
0
      }
11747
570
    }
11748
571
    ZEND_VM_NEXT_OPCODE();
11749
8.18k
  } else {
11750
8.18k
    SAVE_OPLINE();
11751
11752
8.18k
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11753
0
      op1 = ZVAL_UNDEFINED_OP1();
11754
0
    }
11755
8.18k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
11756
7.72k
      op2 = ZVAL_UNDEFINED_OP2();
11757
7.72k
    }
11758
8.18k
    concat_function(EX_VAR(opline->result.var), op1, op2);
11759
11760
11761
8.18k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11762
8.18k
  }
11763
8.76k
}
11764
11765
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11766
0
{
11767
0
  USE_OPLINE
11768
0
  zval *op1, *op2;
11769
11770
0
  SAVE_OPLINE();
11771
0
  op1 = RT_CONSTANT(opline, opline->op1);
11772
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11773
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
11774
11775
11776
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11777
0
}
11778
11779
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11780
317
{
11781
317
  USE_OPLINE
11782
317
  zval *container, *dim, *value;
11783
11784
317
  SAVE_OPLINE();
11785
317
  container = RT_CONSTANT(opline, opline->op1);
11786
317
  dim = EX_VAR(opline->op2.var);
11787
317
  if (IS_CONST != IS_CONST) {
11788
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11789
0
fetch_dim_r_array:
11790
0
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
11791
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
11792
0
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
11793
0
      container = Z_REFVAL_P(container);
11794
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11795
0
        goto fetch_dim_r_array;
11796
0
      } else {
11797
0
        goto fetch_dim_r_slow;
11798
0
      }
11799
0
    } else {
11800
0
fetch_dim_r_slow:
11801
0
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
11802
0
        dim++;
11803
0
      }
11804
0
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
11805
0
    }
11806
317
  } else {
11807
317
    zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
11808
317
  }
11809
11810
11811
317
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11812
317
}
11813
11814
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11815
0
{
11816
0
  USE_OPLINE
11817
0
  zval *container;
11818
11819
0
  SAVE_OPLINE();
11820
0
  container = RT_CONSTANT(opline, opline->op1);
11821
0
  zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
11822
11823
11824
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11825
0
}
11826
11827
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11828
0
{
11829
#if 0
11830
  USE_OPLINE
11831
#endif
11832
11833
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
11834
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
11835
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11836
0
    }
11837
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11838
0
  } else {
11839
0
    if (IS_CV == IS_UNUSED) {
11840
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11841
0
    }
11842
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11843
0
  }
11844
0
}
11845
11846
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11847
0
{
11848
0
  USE_OPLINE
11849
0
  zval *container;
11850
0
  void **cache_slot = NULL;
11851
11852
0
  SAVE_OPLINE();
11853
0
  container = RT_CONSTANT(opline, opline->op1);
11854
11855
0
  if (IS_CONST == IS_CONST ||
11856
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11857
0
    do {
11858
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11859
0
        container = Z_REFVAL_P(container);
11860
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11861
0
          break;
11862
0
        }
11863
0
      }
11864
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
11865
0
        ZVAL_UNDEFINED_OP1();
11866
0
      }
11867
0
      zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11868
0
      ZVAL_NULL(EX_VAR(opline->result.var));
11869
0
      goto fetch_obj_r_finish;
11870
0
    } while (0);
11871
0
  }
11872
11873
  /* here we are sure we are dealing with an object */
11874
0
  do {
11875
0
    zend_object *zobj = Z_OBJ_P(container);
11876
0
    zend_string *name, *tmp_name;
11877
0
    zval *retval;
11878
11879
0
    if (IS_CV == IS_CONST) {
11880
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
11881
11882
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11883
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11884
11885
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11886
0
fetch_obj_r_simple:
11887
0
          retval = OBJ_PROP(zobj, prop_offset);
11888
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
11889
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11890
0
              goto fetch_obj_r_copy;
11891
0
            } else {
11892
0
fetch_obj_r_fast_copy:
11893
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11894
0
              ZEND_VM_NEXT_OPCODE();
11895
0
            }
11896
0
          }
11897
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
11898
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
11899
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
11900
0
            prop_offset = prop_info->offset;
11901
0
            goto fetch_obj_r_simple;
11902
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
11903
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
11904
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
11905
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
11906
11907
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
11908
0
            if (IS_CONST & IS_CV) {
11909
0
              GC_ADDREF(zobj);
11910
0
            }
11911
0
            if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
11912
0
              call_info |= ZEND_CALL_RELEASE_THIS;
11913
0
            }
11914
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
11915
0
            call->prev_execute_data = execute_data;
11916
0
            call->call = NULL;
11917
0
            call->return_value = EX_VAR(opline->result.var);
11918
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
11919
11920
0
            execute_data = call;
11921
0
            EG(current_execute_data) = execute_data;
11922
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
11923
11924
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
11925
            opline = hook->op_array.opcodes;
11926
#else
11927
0
            EX(opline) = hook->op_array.opcodes;
11928
0
#endif
11929
0
            LOAD_OPLINE_EX();
11930
11931
11932
0
            ZEND_VM_ENTER_EX();
11933
0
          }
11934
          /* Fall through to read_property for hooks. */
11935
0
        } else if (EXPECTED(zobj->properties != NULL)) {
11936
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
11937
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11938
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11939
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11940
11941
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11942
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11943
11944
0
              if (EXPECTED(p->key == name) ||
11945
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
11946
0
                   EXPECTED(p->key != NULL) &&
11947
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
11948
0
                retval = &p->val;
11949
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11950
0
                  goto fetch_obj_r_copy;
11951
0
                } else {
11952
0
                  goto fetch_obj_r_fast_copy;
11953
0
                }
11954
0
              }
11955
0
            }
11956
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11957
0
          }
11958
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
11959
0
          if (EXPECTED(retval)) {
11960
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11961
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11962
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11963
0
              goto fetch_obj_r_copy;
11964
0
            } else {
11965
0
              goto fetch_obj_r_fast_copy;
11966
0
            }
11967
0
          }
11968
0
        }
11969
0
      }
11970
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11971
0
    } else {
11972
0
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11973
0
      if (UNEXPECTED(!name)) {
11974
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
11975
0
        break;
11976
0
      }
11977
0
    }
11978
11979
0
#if ZEND_DEBUG
11980
    /* For non-standard object handlers, verify a declared property type in debug builds.
11981
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
11982
0
    zend_property_info *prop_info = NULL;
11983
0
    if (zobj->handlers->read_property != zend_std_read_property) {
11984
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
11985
0
    }
11986
0
#endif
11987
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
11988
0
#if ZEND_DEBUG
11989
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
11990
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
11991
0
      ZVAL_OPT_DEREF(retval);
11992
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
11993
0
    }
11994
0
#endif
11995
11996
0
    if (IS_CV != IS_CONST) {
11997
0
      zend_tmp_string_release(tmp_name);
11998
0
    }
11999
12000
0
    if (retval != EX_VAR(opline->result.var)) {
12001
0
fetch_obj_r_copy:
12002
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
12003
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
12004
0
      zend_unwrap_reference(retval);
12005
0
    }
12006
0
  } while (0);
12007
12008
0
fetch_obj_r_finish:
12009
12010
12011
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12012
0
}
12013
12014
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12015
0
{
12016
0
  USE_OPLINE
12017
0
  zval *container;
12018
0
  void **cache_slot = NULL;
12019
12020
0
  SAVE_OPLINE();
12021
0
  container = RT_CONSTANT(opline, opline->op1);
12022
12023
0
  if (IS_CONST == IS_CONST ||
12024
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
12025
0
    do {
12026
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
12027
0
        container = Z_REFVAL_P(container);
12028
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
12029
0
          break;
12030
0
        }
12031
0
      }
12032
0
      if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
12033
0
        ZVAL_UNDEFINED_OP2();
12034
0
      }
12035
0
      ZVAL_NULL(EX_VAR(opline->result.var));
12036
0
      goto fetch_obj_is_finish;
12037
0
    } while (0);
12038
0
  }
12039
12040
  /* here we are sure we are dealing with an object */
12041
0
  do {
12042
0
    zend_object *zobj = Z_OBJ_P(container);
12043
0
    zend_string *name, *tmp_name;
12044
0
    zval *retval;
12045
12046
0
    if (IS_CV == IS_CONST) {
12047
0
      cache_slot = CACHE_ADDR(opline->extended_value);
12048
12049
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
12050
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
12051
12052
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
12053
0
fetch_obj_is_simple:
12054
0
          retval = OBJ_PROP(zobj, prop_offset);
12055
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
12056
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
12057
0
              goto fetch_obj_is_copy;
12058
0
            } else {
12059
0
fetch_obj_is_fast_copy:
12060
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
12061
0
              ZEND_VM_NEXT_OPCODE();
12062
0
            }
12063
0
          }
12064
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
12065
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
12066
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
12067
0
            prop_offset = prop_info->offset;
12068
0
            goto fetch_obj_is_simple;
12069
0
          }
12070
          /* Fall through to read_property for hooks. */
12071
0
        } else if (EXPECTED(zobj->properties != NULL)) {
12072
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
12073
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
12074
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
12075
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
12076
12077
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
12078
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
12079
12080
0
              if (EXPECTED(p->key == name) ||
12081
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
12082
0
                   EXPECTED(p->key != NULL) &&
12083
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
12084
0
                retval = &p->val;
12085
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
12086
0
                  goto fetch_obj_is_copy;
12087
0
                } else {
12088
0
                  goto fetch_obj_is_fast_copy;
12089
0
                }
12090
0
              }
12091
0
            }
12092
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
12093
0
          }
12094
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
12095
0
          if (EXPECTED(retval)) {
12096
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
12097
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
12098
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
12099
0
              goto fetch_obj_is_copy;
12100
0
            } else {
12101
0
              goto fetch_obj_is_fast_copy;
12102
0
            }
12103
0
          }
12104
0
        }
12105
0
      }
12106
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
12107
0
    } else {
12108
0
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
12109
0
      if (UNEXPECTED(!name)) {
12110
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
12111
0
        break;
12112
0
      }
12113
0
    }
12114
12115
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
12116
12117
0
    if (IS_CV != IS_CONST) {
12118
0
      zend_tmp_string_release(tmp_name);
12119
0
    }
12120
12121
0
    if (retval != EX_VAR(opline->result.var)) {
12122
0
fetch_obj_is_copy:
12123
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
12124
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
12125
0
      zend_unwrap_reference(retval);
12126
0
    }
12127
0
  } while (0);
12128
12129
0
fetch_obj_is_finish:
12130
12131
12132
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12133
0
}
12134
12135
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12136
0
{
12137
#if 0
12138
  USE_OPLINE
12139
#endif
12140
12141
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
12142
    /* Behave like FETCH_OBJ_W */
12143
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
12144
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12145
0
    }
12146
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12147
0
  } else {
12148
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12149
0
  }
12150
0
}
12151
12152
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12153
15
{
12154
15
  USE_OPLINE
12155
15
  zval *container;
12156
12157
15
  SAVE_OPLINE();
12158
15
  container = RT_CONSTANT(opline, opline->op1);
12159
15
  zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
12160
12161
15
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12162
15
}
12163
12164
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12165
6.68k
{
12166
6.68k
  USE_OPLINE
12167
6.68k
  zval *op1, *op2;
12168
6.68k
  zend_string *op1_str, *op2_str, *str;
12169
12170
12171
6.68k
  op1 = RT_CONSTANT(opline, opline->op1);
12172
6.68k
  op2 = EX_VAR(opline->op2.var);
12173
6.68k
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
12174
6.68k
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
12175
730
    zend_string *op1_str = Z_STR_P(op1);
12176
730
    zend_string *op2_str = Z_STR_P(op2);
12177
730
    zend_string *str;
12178
730
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
12179
12180
730
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
12181
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
12182
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
12183
0
      } else {
12184
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
12185
0
      }
12186
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
12187
0
        zend_string_release_ex(op1_str, 0);
12188
0
      }
12189
730
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
12190
13
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
12191
13
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
12192
13
      } else {
12193
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
12194
0
      }
12195
13
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12196
0
        zend_string_release_ex(op2_str, 0);
12197
0
      }
12198
717
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
12199
717
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
12200
0
      size_t len = ZSTR_LEN(op1_str);
12201
12202
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
12203
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12204
0
      GC_ADD_FLAGS(str, flags);
12205
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12206
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12207
0
        zend_string_release_ex(op2_str, 0);
12208
0
      }
12209
717
    } else {
12210
717
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
12211
717
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
12212
717
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12213
717
      GC_ADD_FLAGS(str, flags);
12214
717
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12215
717
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
12216
0
        zend_string_release_ex(op1_str, 0);
12217
0
      }
12218
717
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12219
0
        zend_string_release_ex(op2_str, 0);
12220
0
      }
12221
717
    }
12222
730
    ZEND_VM_NEXT_OPCODE();
12223
730
  }
12224
12225
6.68k
  SAVE_OPLINE();
12226
5.95k
  if (IS_CONST == IS_CONST) {
12227
5.95k
    op1_str = Z_STR_P(op1);
12228
5.95k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
12229
0
    op1_str = zend_string_copy(Z_STR_P(op1));
12230
0
  } else {
12231
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
12232
0
      ZVAL_UNDEFINED_OP1();
12233
0
    }
12234
0
    op1_str = zval_get_string_func(op1);
12235
0
  }
12236
5.95k
  if (IS_CV == IS_CONST) {
12237
0
    op2_str = Z_STR_P(op2);
12238
5.95k
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
12239
0
    op2_str = zend_string_copy(Z_STR_P(op2));
12240
5.95k
  } else {
12241
5.95k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
12242
3.65k
      ZVAL_UNDEFINED_OP2();
12243
3.65k
    }
12244
5.95k
    op2_str = zval_get_string_func(op2);
12245
5.95k
  }
12246
5.95k
  do {
12247
5.95k
    if (IS_CONST != IS_CONST) {
12248
0
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
12249
0
        if (IS_CV == IS_CONST) {
12250
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
12251
0
            GC_ADDREF(op2_str);
12252
0
          }
12253
0
        }
12254
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
12255
0
        zend_string_release_ex(op1_str, 0);
12256
0
        break;
12257
0
      }
12258
0
    }
12259
5.95k
    if (IS_CV != IS_CONST) {
12260
5.95k
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
12261
3.66k
        if (IS_CONST == IS_CONST) {
12262
3.66k
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
12263
0
            GC_ADDREF(op1_str);
12264
0
          }
12265
3.66k
        }
12266
3.66k
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
12267
3.66k
        zend_string_release_ex(op2_str, 0);
12268
3.66k
        break;
12269
3.66k
      }
12270
5.95k
    }
12271
2.29k
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
12272
2.29k
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
12273
2.29k
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12274
12275
2.29k
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
12276
2.29k
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12277
2.29k
    if (IS_CONST != IS_CONST) {
12278
0
      zend_string_release_ex(op1_str, 0);
12279
0
    }
12280
2.29k
    if (IS_CV != IS_CONST) {
12281
2.29k
      zend_string_release_ex(op2_str, 0);
12282
2.29k
    }
12283
2.29k
  } while (0);
12284
12285
12286
5.95k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12287
5.95k
}
12288
12289
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12290
2
{
12291
2
  USE_OPLINE
12292
2
  zval *function_name;
12293
2
  zval *object;
12294
2
  zend_function *fbc;
12295
2
  zend_class_entry *called_scope;
12296
2
  zend_object *obj;
12297
2
  zend_execute_data *call;
12298
2
  uint32_t call_info;
12299
12300
2
  SAVE_OPLINE();
12301
12302
2
  object = RT_CONSTANT(opline, opline->op1);
12303
12304
2
  if (IS_CV != IS_CONST) {
12305
2
    function_name = EX_VAR(opline->op2.var);
12306
2
  }
12307
12308
2
  if (IS_CV != IS_CONST &&
12309
2
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12310
0
    do {
12311
0
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
12312
0
        function_name = Z_REFVAL_P(function_name);
12313
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12314
0
          break;
12315
0
        }
12316
0
      } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12317
0
        ZVAL_UNDEFINED_OP2();
12318
0
        if (UNEXPECTED(EG(exception) != NULL)) {
12319
12320
0
          HANDLE_EXCEPTION();
12321
0
        }
12322
0
      }
12323
0
      zend_throw_error(NULL, "Method name must be a string");
12324
12325
12326
0
      HANDLE_EXCEPTION();
12327
0
    } while (0);
12328
0
  }
12329
12330
2
  if (IS_CONST == IS_UNUSED) {
12331
0
    obj = Z_OBJ_P(object);
12332
2
  } else {
12333
2
    do {
12334
2
      if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
12335
0
        obj = Z_OBJ_P(object);
12336
2
      } else {
12337
2
        if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
12338
0
          zend_reference *ref = Z_REF_P(object);
12339
12340
0
          object = &ref->val;
12341
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
12342
0
            obj = Z_OBJ_P(object);
12343
0
            if (IS_CONST & IS_VAR) {
12344
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12345
0
                efree_size(ref, sizeof(zend_reference));
12346
0
              } else {
12347
0
                Z_ADDREF_P(object);
12348
0
              }
12349
0
            }
12350
0
            break;
12351
0
          }
12352
0
        }
12353
2
        if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
12354
0
          object = ZVAL_UNDEFINED_OP1();
12355
0
          if (UNEXPECTED(EG(exception) != NULL)) {
12356
0
            if (IS_CV != IS_CONST) {
12357
12358
0
            }
12359
0
            HANDLE_EXCEPTION();
12360
0
          }
12361
0
        }
12362
2
        if (IS_CV == IS_CONST) {
12363
0
          function_name = EX_VAR(opline->op2.var);
12364
0
        }
12365
2
        zend_invalid_method_call(object, function_name);
12366
12367
12368
2
        HANDLE_EXCEPTION();
12369
2
      }
12370
2
    } while (0);
12371
2
  }
12372
12373
0
  called_scope = obj->ce;
12374
12375
0
  if (IS_CV == IS_CONST &&
12376
0
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
12377
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12378
0
  } else {
12379
0
    zend_object *orig_obj = obj;
12380
12381
0
    if (IS_CV == IS_CONST) {
12382
0
      function_name = EX_VAR(opline->op2.var);
12383
0
    }
12384
12385
    /* First, locate the function. */
12386
0
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12387
0
    if (UNEXPECTED(fbc == NULL)) {
12388
0
      if (EXPECTED(!EG(exception))) {
12389
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
12390
0
      }
12391
12392
0
      if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
12393
0
        zend_objects_store_del(orig_obj);
12394
0
      }
12395
0
      HANDLE_EXCEPTION();
12396
0
    }
12397
0
    if (IS_CV == IS_CONST &&
12398
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12399
0
        EXPECTED(obj == orig_obj)) {
12400
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
12401
0
    }
12402
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
12403
0
      GC_ADDREF(obj); /* For $this pointer */
12404
0
      if (GC_DELREF(orig_obj) == 0) {
12405
0
        zend_objects_store_del(orig_obj);
12406
0
      }
12407
0
    }
12408
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12409
0
      init_func_run_time_cache(&fbc->op_array);
12410
0
    }
12411
0
  }
12412
12413
0
  if (IS_CV != IS_CONST) {
12414
12415
0
  }
12416
12417
0
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12418
0
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
12419
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
12420
0
      zend_objects_store_del(obj);
12421
0
      if (UNEXPECTED(EG(exception))) {
12422
0
        HANDLE_EXCEPTION();
12423
0
      }
12424
0
    }
12425
    /* call static method */
12426
0
    obj = (zend_object*)called_scope;
12427
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
12428
0
  } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
12429
0
    if (IS_CONST == IS_CV) {
12430
0
      GC_ADDREF(obj); /* For $this pointer */
12431
0
    }
12432
    /* CV may be changed indirectly (e.g. when it's a reference) */
12433
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
12434
0
  }
12435
12436
0
  call = zend_vm_stack_push_call_frame(call_info,
12437
0
    fbc, opline->extended_value, obj);
12438
0
  call->prev_execute_data = EX(call);
12439
0
  EX(call) = call;
12440
12441
0
  ZEND_VM_NEXT_OPCODE();
12442
0
}
12443
12444
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12445
44
{
12446
44
  USE_OPLINE
12447
44
  zval *function_name;
12448
44
  zend_class_entry *ce;
12449
44
  uint32_t call_info;
12450
44
  zend_function *fbc;
12451
44
  zend_execute_data *call;
12452
12453
44
  SAVE_OPLINE();
12454
12455
44
  if (IS_CONST == IS_CONST) {
12456
    /* no function found. try a static method in class */
12457
44
    ce = CACHED_PTR(opline->result.num);
12458
44
    if (UNEXPECTED(ce == NULL)) {
12459
34
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
12460
34
      if (UNEXPECTED(ce == NULL)) {
12461
12462
5
        HANDLE_EXCEPTION();
12463
5
      }
12464
29
      if (IS_CV != IS_CONST) {
12465
29
        CACHE_PTR(opline->result.num, ce);
12466
29
      }
12467
29
    }
12468
44
  } else if (IS_CONST == IS_UNUSED) {
12469
0
    ce = zend_fetch_class(NULL, opline->op1.num);
12470
0
    if (UNEXPECTED(ce == NULL)) {
12471
12472
0
      HANDLE_EXCEPTION();
12473
0
    }
12474
0
  } else {
12475
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
12476
0
  }
12477
12478
39
  if (IS_CONST == IS_CONST &&
12479
39
      IS_CV == IS_CONST &&
12480
39
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
12481
    /* nothing to do */
12482
39
  } else if (IS_CONST != IS_CONST &&
12483
39
             IS_CV == IS_CONST &&
12484
39
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
12485
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12486
39
  } else if (IS_CV != IS_UNUSED) {
12487
39
    function_name = EX_VAR(opline->op2.var);
12488
39
    if (IS_CV != IS_CONST) {
12489
39
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12490
15
        do {
12491
15
          if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
12492
0
            function_name = Z_REFVAL_P(function_name);
12493
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12494
0
              break;
12495
0
            }
12496
15
          } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12497
10
            ZVAL_UNDEFINED_OP2();
12498
10
            if (UNEXPECTED(EG(exception) != NULL)) {
12499
5
              HANDLE_EXCEPTION();
12500
5
            }
12501
10
          }
12502
10
          zend_throw_error(NULL, "Method name must be a string");
12503
12504
10
          HANDLE_EXCEPTION();
12505
10
        } while (0);
12506
15
      }
12507
39
    }
12508
12509
24
    if (ce->get_static_method) {
12510
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
12511
24
    } else {
12512
24
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12513
24
    }
12514
24
    if (UNEXPECTED(fbc == NULL)) {
12515
4
      if (EXPECTED(!EG(exception))) {
12516
4
        zend_undefined_method(ce, Z_STR_P(function_name));
12517
4
      }
12518
12519
4
      HANDLE_EXCEPTION();
12520
4
    }
12521
20
    if (IS_CV == IS_CONST &&
12522
20
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12523
20
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
12524
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
12525
0
    }
12526
20
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12527
5
      init_func_run_time_cache(&fbc->op_array);
12528
5
    }
12529
20
    if (IS_CV != IS_CONST) {
12530
12531
20
    }
12532
20
  } else {
12533
0
    if (UNEXPECTED(ce->constructor == NULL)) {
12534
0
      zend_throw_error(NULL, "Cannot call constructor");
12535
0
      HANDLE_EXCEPTION();
12536
0
    }
12537
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
12538
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
12539
0
      HANDLE_EXCEPTION();
12540
0
    }
12541
0
    fbc = ce->constructor;
12542
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12543
0
      init_func_run_time_cache(&fbc->op_array);
12544
0
    }
12545
0
  }
12546
12547
20
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
12548
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
12549
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
12550
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12551
0
    } else {
12552
0
      zend_non_static_method_call(fbc);
12553
0
      HANDLE_EXCEPTION();
12554
0
    }
12555
20
  } else {
12556
    /* previous opcode is ZEND_FETCH_CLASS */
12557
20
    if (IS_CONST == IS_UNUSED
12558
20
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
12559
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
12560
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
12561
0
        ce = Z_OBJCE(EX(This));
12562
0
      } else {
12563
0
        ce = Z_CE(EX(This));
12564
0
      }
12565
0
    }
12566
20
    call_info = ZEND_CALL_NESTED_FUNCTION;
12567
20
  }
12568
12569
20
  call = zend_vm_stack_push_call_frame(call_info,
12570
20
    fbc, opline->extended_value, ce);
12571
20
  call->prev_execute_data = EX(call);
12572
20
  EX(call) = call;
12573
12574
20
  ZEND_VM_NEXT_OPCODE();
12575
20
}
12576
12577
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12578
342
{
12579
342
  USE_OPLINE
12580
342
  zval *function_name;
12581
342
  zend_fcall_info_cache fcc;
12582
342
  char *error = NULL;
12583
342
  zend_function *func;
12584
342
  void *object_or_called_scope;
12585
342
  zend_execute_data *call;
12586
342
  uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
12587
12588
342
  SAVE_OPLINE();
12589
342
  function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12590
342
  if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
12591
337
    ZEND_ASSERT(!error);
12592
12593
    /* Deprecation can be emitted from zend_is_callable_ex(), which can
12594
     * invoke a user error handler and throw an exception.
12595
     * For the CONST and CV case we reuse the same exception block below
12596
     * to make sure we don't increase VM size too much. */
12597
337
    if (!(IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12598
12599
0
      HANDLE_EXCEPTION();
12600
0
    }
12601
12602
337
    func = fcc.function_handler;
12603
337
    object_or_called_scope = fcc.called_scope;
12604
337
    if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
12605
      /* Delay closure destruction until its invocation */
12606
72
      GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
12607
72
      call_info |= ZEND_CALL_CLOSURE;
12608
72
      if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
12609
0
        call_info |= ZEND_CALL_FAKE_CLOSURE;
12610
0
      }
12611
72
      if (fcc.object) {
12612
0
        object_or_called_scope = fcc.object;
12613
0
        call_info |= ZEND_CALL_HAS_THIS;
12614
0
      }
12615
265
    } else if (fcc.object) {
12616
226
      GC_ADDREF(fcc.object); /* For $this pointer */
12617
226
      object_or_called_scope = fcc.object;
12618
226
      call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
12619
226
    }
12620
12621
337
    if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12622
0
      if (call_info & ZEND_CALL_CLOSURE) {
12623
0
        zend_object_release(ZEND_CLOSURE_OBJECT(func));
12624
0
      } else if (call_info & ZEND_CALL_RELEASE_THIS) {
12625
0
        zend_object_release(fcc.object);
12626
0
      }
12627
0
      HANDLE_EXCEPTION();
12628
0
    }
12629
12630
337
    if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
12631
7
      init_func_run_time_cache(&func->op_array);
12632
7
    }
12633
337
  } else {
12634
5
    zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
12635
5
    efree(error);
12636
12637
5
    HANDLE_EXCEPTION();
12638
5
  }
12639
12640
337
  call = zend_vm_stack_push_call_frame(call_info,
12641
337
    func, opline->extended_value, object_or_called_scope);
12642
337
  call->prev_execute_data = EX(call);
12643
337
  EX(call) = call;
12644
12645
337
  ZEND_VM_NEXT_OPCODE();
12646
337
}
12647
12648
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12649
487
{
12650
487
  USE_OPLINE
12651
487
  zval *expr_ptr, new_expr;
12652
12653
487
  SAVE_OPLINE();
12654
487
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
12655
487
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
12656
0
    expr_ptr = zend_get_bad_ptr();
12657
0
    if (Z_ISREF_P(expr_ptr)) {
12658
0
      Z_ADDREF_P(expr_ptr);
12659
0
    } else {
12660
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
12661
0
    }
12662
12663
487
  } else {
12664
487
    expr_ptr = RT_CONSTANT(opline, opline->op1);
12665
487
    if (IS_CONST == IS_TMP_VAR) {
12666
      /* pass */
12667
487
    } else if (IS_CONST == IS_CONST) {
12668
487
      Z_TRY_ADDREF_P(expr_ptr);
12669
487
    } else if (IS_CONST == IS_CV) {
12670
0
      ZVAL_DEREF(expr_ptr);
12671
0
      Z_TRY_ADDREF_P(expr_ptr);
12672
0
    } else /* if (IS_CONST == IS_VAR) */ {
12673
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
12674
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
12675
12676
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
12677
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12678
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
12679
0
          expr_ptr = &new_expr;
12680
0
          efree_size(ref, sizeof(zend_reference));
12681
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
12682
0
          Z_ADDREF_P(expr_ptr);
12683
0
        }
12684
0
      }
12685
0
    }
12686
487
  }
12687
12688
487
  if (IS_CV != IS_UNUSED) {
12689
487
    zval *offset = EX_VAR(opline->op2.var);
12690
487
    zend_string *str;
12691
487
    zend_ulong hval;
12692
12693
487
add_again:
12694
487
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12695
10
      str = Z_STR_P(offset);
12696
10
      if (IS_CV != IS_CONST) {
12697
10
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
12698
0
          goto num_index;
12699
0
        }
12700
10
      }
12701
29
str_index:
12702
29
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
12703
477
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12704
431
      hval = Z_LVAL_P(offset);
12705
458
num_index:
12706
458
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
12707
458
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
12708
0
      offset = Z_REFVAL_P(offset);
12709
0
      goto add_again;
12710
46
    } else if (Z_TYPE_P(offset) == IS_NULL) {
12711
2
      str = ZSTR_EMPTY_ALLOC();
12712
2
      goto str_index;
12713
44
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
12714
27
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
12715
27
      goto num_index;
12716
27
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
12717
0
      hval = 0;
12718
0
      goto num_index;
12719
17
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
12720
0
      hval = 1;
12721
0
      goto num_index;
12722
17
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
12723
0
      zend_use_resource_as_offset(offset);
12724
0
      hval = Z_RES_HANDLE_P(offset);
12725
0
      goto num_index;
12726
17
    } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
12727
17
      ZVAL_UNDEFINED_OP2();
12728
17
      str = ZSTR_EMPTY_ALLOC();
12729
17
      goto str_index;
12730
17
    } else {
12731
0
      zend_illegal_array_offset_access(offset);
12732
0
      zval_ptr_dtor_nogc(expr_ptr);
12733
0
    }
12734
12735
487
  } else {
12736
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
12737
0
      zend_cannot_add_element();
12738
0
      zval_ptr_dtor_nogc(expr_ptr);
12739
0
    }
12740
0
  }
12741
487
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12742
487
}
12743
12744
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12745
453
{
12746
453
  zval *array;
12747
453
  uint32_t size;
12748
453
  USE_OPLINE
12749
12750
453
  SAVE_OPLINE();
12751
453
  array = EX_VAR(opline->result.var);
12752
453
  if (IS_CONST != IS_UNUSED) {
12753
453
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
12754
453
    ZVAL_ARR(array, zend_new_array(size));
12755
    /* Explicitly initialize array as not-packed if flag is set */
12756
453
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
12757
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
12758
0
    }
12759
453
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12760
453
  } else {
12761
0
    ZVAL_ARR(array, zend_new_array(0));
12762
0
    ZEND_VM_NEXT_OPCODE();
12763
0
  }
12764
453
}
12765
12766
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12767
336
{
12768
336
  USE_OPLINE
12769
336
  zval *container;
12770
336
  bool result;
12771
336
  zend_ulong hval;
12772
336
  zval *offset;
12773
12774
336
  SAVE_OPLINE();
12775
336
  container = RT_CONSTANT(opline, opline->op1);
12776
336
  offset = EX_VAR(opline->op2.var);
12777
12778
336
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12779
332
    HashTable *ht;
12780
332
    zval *value;
12781
332
    zend_string *str;
12782
12783
332
isset_dim_obj_array:
12784
332
    ht = Z_ARRVAL_P(container);
12785
332
isset_again:
12786
332
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12787
0
      str = Z_STR_P(offset);
12788
0
      if (IS_CV != IS_CONST) {
12789
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
12790
0
          goto num_index_prop;
12791
0
        }
12792
0
      }
12793
0
      value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
12794
332
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12795
332
      hval = Z_LVAL_P(offset);
12796
332
num_index_prop:
12797
332
      value = zend_hash_index_find(ht, hval);
12798
332
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
12799
0
      offset = Z_REFVAL_P(offset);
12800
0
      goto isset_again;
12801
0
    } else {
12802
0
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
12803
0
      if (UNEXPECTED(EG(exception))) {
12804
0
        result = 0;
12805
0
        goto isset_dim_obj_exit;
12806
0
      }
12807
0
    }
12808
12809
332
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
12810
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
12811
332
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
12812
332
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
12813
12814
332
      if (IS_CONST & (IS_CONST|IS_CV)) {
12815
        /* avoid exception check */
12816
12817
332
        ZEND_VM_SMART_BRANCH(result, 0);
12818
332
      }
12819
332
    } else {
12820
0
      result = (value == NULL || !i_zend_is_true(value));
12821
0
    }
12822
0
    goto isset_dim_obj_exit;
12823
332
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
12824
0
    container = Z_REFVAL_P(container);
12825
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12826
0
      goto isset_dim_obj_array;
12827
0
    }
12828
0
  }
12829
12830
4
  if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
12831
0
    offset++;
12832
0
  }
12833
4
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
12834
4
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
12835
4
  } else {
12836
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
12837
0
  }
12838
12839
4
isset_dim_obj_exit:
12840
12841
12842
4
  ZEND_VM_SMART_BRANCH(result, 1);
12843
4
}
12844
12845
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12846
0
{
12847
0
  USE_OPLINE
12848
0
  zval *container;
12849
0
  int result;
12850
0
  zval *offset;
12851
0
  zend_string *name, *tmp_name;
12852
12853
0
  SAVE_OPLINE();
12854
0
  container = RT_CONSTANT(opline, opline->op1);
12855
0
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12856
12857
0
  if (IS_CONST == IS_CONST ||
12858
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
12859
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
12860
0
      container = Z_REFVAL_P(container);
12861
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
12862
0
        result = (opline->extended_value & ZEND_ISEMPTY);
12863
0
        goto isset_object_finish;
12864
0
      }
12865
0
    } else {
12866
0
      result = (opline->extended_value & ZEND_ISEMPTY);
12867
0
      goto isset_object_finish;
12868
0
    }
12869
0
  }
12870
12871
0
  if (IS_CV == IS_CONST) {
12872
0
    name = Z_STR_P(offset);
12873
0
  } else {
12874
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
12875
0
    if (UNEXPECTED(!name)) {
12876
0
      result = 0;
12877
0
      goto isset_object_finish;
12878
0
    }
12879
0
  }
12880
12881
0
  result =
12882
0
    (opline->extended_value & ZEND_ISEMPTY) ^
12883
0
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
12884
12885
0
  if (IS_CV != IS_CONST) {
12886
0
    zend_tmp_string_release(tmp_name);
12887
0
  }
12888
12889
0
isset_object_finish:
12890
12891
12892
0
  ZEND_VM_SMART_BRANCH(result, 1);
12893
0
}
12894
12895
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12896
12
{
12897
12
  USE_OPLINE
12898
12899
12
  zval *key, *subject;
12900
12
  HashTable *ht;
12901
12
  bool result;
12902
12903
12
  SAVE_OPLINE();
12904
12905
12
  key = RT_CONSTANT(opline, opline->op1);
12906
12
  subject = EX_VAR(opline->op2.var);
12907
12908
12
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12909
10
array_key_exists_array:
12910
10
    ht = Z_ARRVAL_P(subject);
12911
10
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
12912
10
  } else {
12913
2
    if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
12914
0
      subject = Z_REFVAL_P(subject);
12915
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12916
0
        goto array_key_exists_array;
12917
0
      }
12918
0
    }
12919
2
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
12920
2
    result = 0;
12921
2
  }
12922
12923
12924
12
  ZEND_VM_SMART_BRANCH(result, 1);
12925
12
}
12926
12927
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12928
46
{
12929
46
  USE_OPLINE
12930
12931
46
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
12932
12933
46
  SAVE_OPLINE();
12934
46
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
12935
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12936
0
  }
12937
12938
  /* Destroy the previously yielded value */
12939
46
  zval_ptr_dtor(&generator->value);
12940
12941
  /* Destroy the previously yielded key */
12942
46
  zval_ptr_dtor(&generator->key);
12943
12944
  /* Set the new yielded value */
12945
46
  if (IS_CONST != IS_UNUSED) {
12946
46
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
12947
      /* Constants and temporary variables aren't yieldable by reference,
12948
       * but we still allow them with a notice. */
12949
0
      if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
12950
0
        zval *value;
12951
12952
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12953
12954
0
        value = RT_CONSTANT(opline, opline->op1);
12955
0
        ZVAL_COPY_VALUE(&generator->value, value);
12956
0
        if (IS_CONST == IS_CONST) {
12957
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12958
0
            Z_ADDREF(generator->value);
12959
0
          }
12960
0
        }
12961
0
      } else {
12962
0
        zval *value_ptr = zend_get_bad_ptr();
12963
12964
        /* If a function call result is yielded and the function did
12965
         * not return by reference we throw a notice. */
12966
0
        do {
12967
0
          if (IS_CONST == IS_VAR) {
12968
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
12969
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
12970
0
             && !Z_ISREF_P(value_ptr)) {
12971
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12972
0
              ZVAL_COPY(&generator->value, value_ptr);
12973
0
              break;
12974
0
            }
12975
0
          }
12976
0
          if (Z_ISREF_P(value_ptr)) {
12977
0
            Z_ADDREF_P(value_ptr);
12978
0
          } else {
12979
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
12980
0
          }
12981
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
12982
0
        } while (0);
12983
12984
0
      }
12985
46
    } else {
12986
46
      zval *value = RT_CONSTANT(opline, opline->op1);
12987
12988
      /* Consts, temporary variables and references need copying */
12989
46
      if (IS_CONST == IS_CONST) {
12990
46
        ZVAL_COPY_VALUE(&generator->value, value);
12991
46
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12992
0
          Z_ADDREF(generator->value);
12993
0
        }
12994
46
      } else if (IS_CONST == IS_TMP_VAR) {
12995
0
        ZVAL_COPY_VALUE(&generator->value, value);
12996
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
12997
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
12998
12999
0
      } else {
13000
0
        ZVAL_COPY_VALUE(&generator->value, value);
13001
0
        if (IS_CONST == IS_CV) {
13002
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
13003
0
        }
13004
0
      }
13005
46
    }
13006
46
  } else {
13007
    /* If no value was specified yield null */
13008
0
    ZVAL_NULL(&generator->value);
13009
0
  }
13010
13011
  /* Set the new yielded key */
13012
46
  if (IS_CV != IS_UNUSED) {
13013
46
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
13014
46
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
13015
0
      key = Z_REFVAL_P(key);
13016
0
    }
13017
46
    ZVAL_COPY(&generator->key, key);
13018
13019
46
    if (Z_TYPE(generator->key) == IS_LONG
13020
46
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
13021
46
    ) {
13022
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
13023
0
    }
13024
46
  } else {
13025
    /* If no key was specified we use auto-increment keys */
13026
0
    generator->largest_used_integer_key++;
13027
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
13028
0
  }
13029
13030
46
  if (RETURN_VALUE_USED(opline)) {
13031
    /* If the return value of yield is used set the send
13032
     * target and initialize it to NULL */
13033
3
    generator->send_target = EX_VAR(opline->result.var);
13034
3
    ZVAL_NULL(generator->send_target);
13035
43
  } else {
13036
43
    generator->send_target = NULL;
13037
43
  }
13038
13039
  /* The GOTO VM uses a local opline variable. We need to set the opline
13040
   * variable in execute_data so we don't resume at an old position. */
13041
46
  SAVE_OPLINE();
13042
13043
46
  ZEND_VM_RETURN();
13044
46
}
13045
13046
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13047
9.36k
{
13048
9.36k
  USE_OPLINE
13049
9.36k
  zval *op1;
13050
13051
9.36k
  op1 = EX_VAR(opline->op1.var);
13052
9.36k
  if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13053
4.12k
    ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
13054
4.12k
    ZEND_VM_NEXT_OPCODE();
13055
4.12k
  }
13056
13057
9.36k
  ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1));
13058
9.36k
}
13059
13060
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13061
1.24k
{
13062
1.24k
  USE_OPLINE
13063
1.24k
  zval *value;
13064
13065
1.24k
  value = EX_VAR(opline->op1.var);
13066
1.24k
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
13067
1.24k
  ZEND_VM_NEXT_OPCODE();
13068
1.24k
}
13069
13070
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13071
53
{
13072
53
  USE_OPLINE
13073
53
  zval *value;
13074
13075
53
  value = EX_VAR(opline->op1.var);
13076
53
  ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
13077
53
  ZEND_VM_NEXT_OPCODE();
13078
53
}
13079
13080
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13081
11.8k
{
13082
11.8k
  USE_OPLINE
13083
11.8k
  zval *value;
13084
13085
11.8k
  value = EX_VAR(opline->op1.var);
13086
11.8k
  ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
13087
11.8k
  ZEND_VM_NEXT_OPCODE();
13088
11.8k
}
13089
13090
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13091
7.45k
{
13092
7.45k
  USE_OPLINE
13093
7.45k
  zval *op1, *op2, *result;
13094
7.45k
  double d1, d2;
13095
13096
7.45k
  op1 = EX_VAR(opline->op1.var);
13097
7.45k
  op2 = RT_CONSTANT(opline, opline->op2);
13098
7.45k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13099
    /* pass */
13100
7.45k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13101
6.12k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13102
3.45k
      result = EX_VAR(opline->result.var);
13103
3.45k
      fast_long_add_function(result, op1, op2);
13104
3.45k
      ZEND_VM_NEXT_OPCODE();
13105
3.45k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13106
1.35k
      d1 = (double)Z_LVAL_P(op1);
13107
1.35k
      d2 = Z_DVAL_P(op2);
13108
1.35k
      goto add_double;
13109
1.35k
    }
13110
6.12k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13111
442
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13112
61
      d1 = Z_DVAL_P(op1);
13113
61
      d2 = Z_DVAL_P(op2);
13114
1.61k
add_double:
13115
1.61k
      result = EX_VAR(opline->result.var);
13116
1.61k
      ZVAL_DOUBLE(result, d1 + d2);
13117
1.61k
      ZEND_VM_NEXT_OPCODE();
13118
1.61k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13119
204
      d1 = Z_DVAL_P(op1);
13120
204
      d2 = (double)Z_LVAL_P(op2);
13121
204
      goto add_double;
13122
204
    }
13123
442
  }
13124
13125
7.45k
  ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13126
7.45k
}
13127
13128
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13129
6.31k
{
13130
6.31k
  USE_OPLINE
13131
6.31k
  zval *op1, *op2, *result;
13132
6.31k
  double d1, d2;
13133
13134
6.31k
  op1 = EX_VAR(opline->op1.var);
13135
6.31k
  op2 = RT_CONSTANT(opline, opline->op2);
13136
6.31k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13137
    /* pass */
13138
6.31k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13139
4.49k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13140
4.38k
      result = EX_VAR(opline->result.var);
13141
4.38k
      fast_long_sub_function(result, op1, op2);
13142
4.38k
      ZEND_VM_NEXT_OPCODE();
13143
4.38k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13144
77
      d1 = (double)Z_LVAL_P(op1);
13145
77
      d2 = Z_DVAL_P(op2);
13146
77
      goto sub_double;
13147
77
    }
13148
4.49k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13149
753
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13150
0
      d1 = Z_DVAL_P(op1);
13151
0
      d2 = Z_DVAL_P(op2);
13152
811
sub_double:
13153
811
      result = EX_VAR(opline->result.var);
13154
811
      ZVAL_DOUBLE(result, d1 - d2);
13155
811
      ZEND_VM_NEXT_OPCODE();
13156
811
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13157
734
      d1 = Z_DVAL_P(op1);
13158
734
      d2 = (double)Z_LVAL_P(op2);
13159
734
      goto sub_double;
13160
734
    }
13161
753
  }
13162
13163
6.31k
  ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13164
6.31k
}
13165
13166
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13167
41.8k
{
13168
41.8k
  USE_OPLINE
13169
41.8k
  zval *op1, *op2, *result;
13170
41.8k
  double d1, d2;
13171
13172
41.8k
  op1 = EX_VAR(opline->op1.var);
13173
41.8k
  op2 = RT_CONSTANT(opline, opline->op2);
13174
41.8k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13175
    /* pass */
13176
41.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13177
6.67k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13178
6.19k
      zend_long overflow;
13179
13180
6.19k
      result = EX_VAR(opline->result.var);
13181
6.19k
      ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13182
6.19k
      Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13183
6.19k
      ZEND_VM_NEXT_OPCODE();
13184
6.19k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13185
314
      d1 = (double)Z_LVAL_P(op1);
13186
314
      d2 = Z_DVAL_P(op2);
13187
314
      goto mul_double;
13188
314
    }
13189
35.1k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13190
1.24k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13191
151
      d1 = Z_DVAL_P(op1);
13192
151
      d2 = Z_DVAL_P(op2);
13193
1.47k
mul_double:
13194
1.47k
      result = EX_VAR(opline->result.var);
13195
1.47k
      ZVAL_DOUBLE(result, d1 * d2);
13196
1.47k
      ZEND_VM_NEXT_OPCODE();
13197
1.47k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13198
1.01k
      d1 = Z_DVAL_P(op1);
13199
1.01k
      d2 = (double)Z_LVAL_P(op2);
13200
1.01k
      goto mul_double;
13201
1.01k
    }
13202
1.24k
  }
13203
13204
41.8k
  ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13205
41.8k
}
13206
13207
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13208
1.75k
{
13209
1.75k
  USE_OPLINE
13210
1.75k
  zval *op1, *op2, *result;
13211
13212
1.75k
  op1 = EX_VAR(opline->op1.var);
13213
1.75k
  op2 = RT_CONSTANT(opline, opline->op2);
13214
1.75k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13215
    /* pass */
13216
1.75k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13217
1.70k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13218
1.57k
      result = EX_VAR(opline->result.var);
13219
1.57k
      if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
13220
12
        ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
13221
1.56k
      } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
13222
        /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
13223
10
        ZVAL_LONG(result, 0);
13224
1.55k
      } else {
13225
1.55k
        ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
13226
1.55k
      }
13227
1.56k
      ZEND_VM_NEXT_OPCODE();
13228
1.56k
    }
13229
1.70k
  }
13230
13231
1.75k
  ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13232
1.75k
}
13233
13234
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13235
1.15k
{
13236
1.15k
  USE_OPLINE
13237
1.15k
  zval *op1, *op2;
13238
13239
1.15k
  op1 = EX_VAR(opline->op1.var);
13240
1.15k
  op2 = RT_CONSTANT(opline, opline->op2);
13241
1.15k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13242
    /* pass */
13243
1.15k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13244
1.15k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13245
1.15k
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13246
    /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
13247
51
    ZVAL_LONG(EX_VAR(opline->result.var),
13248
51
      (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
13249
51
    ZEND_VM_NEXT_OPCODE();
13250
51
  }
13251
13252
1.15k
  ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13253
1.15k
}
13254
13255
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13256
1.15k
{
13257
1.15k
  USE_OPLINE
13258
1.15k
  zval *op1, *op2;
13259
13260
1.15k
  op1 = EX_VAR(opline->op1.var);
13261
1.15k
  op2 = RT_CONSTANT(opline, opline->op2);
13262
1.15k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13263
    /* pass */
13264
1.15k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13265
1.15k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13266
1.15k
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13267
1.12k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
13268
1.12k
    ZEND_VM_NEXT_OPCODE();
13269
1.12k
  }
13270
13271
1.15k
  ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13272
1.15k
}
13273
13274
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13275
3.55k
{
13276
3.55k
  USE_OPLINE
13277
3.55k
  zval *op1, *op2;
13278
3.55k
  double d1, d2;
13279
13280
3.55k
  op1 = EX_VAR(opline->op1.var);
13281
3.55k
  op2 = RT_CONSTANT(opline, opline->op2);
13282
3.55k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13283
    /* pass */
13284
3.55k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13285
880
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13286
607
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13287
665
is_smaller_true:
13288
665
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
13289
665
      } else {
13290
84
is_smaller_false:
13291
84
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
13292
84
      }
13293
607
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13294
142
      d1 = (double)Z_LVAL_P(op1);
13295
142
      d2 = Z_DVAL_P(op2);
13296
142
      goto is_smaller_double;
13297
142
    }
13298
2.67k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13299
37
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13300
0
      d1 = Z_DVAL_P(op1);
13301
0
      d2 = Z_DVAL_P(op2);
13302
142
is_smaller_double:
13303
142
      if (d1 < d2) {
13304
142
        goto is_smaller_true;
13305
142
      } else {
13306
0
        goto is_smaller_false;
13307
0
      }
13308
142
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13309
0
      d1 = Z_DVAL_P(op1);
13310
0
      d2 = (double)Z_LVAL_P(op2);
13311
0
      goto is_smaller_double;
13312
0
    }
13313
37
  }
13314
3.55k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13315
3.55k
}
13316
13317
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13318
1.06k
{
13319
1.06k
  USE_OPLINE
13320
1.06k
  zval *op1, *op2;
13321
1.06k
  double d1, d2;
13322
13323
1.06k
  op1 = EX_VAR(opline->op1.var);
13324
1.06k
  op2 = RT_CONSTANT(opline, opline->op2);
13325
1.06k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13326
    /* pass */
13327
1.06k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13328
993
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13329
790
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13330
515
is_smaller_true:
13331
515
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13332
515
      } else {
13333
535
is_smaller_false:
13334
535
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13335
535
      }
13336
790
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13337
203
      d1 = (double)Z_LVAL_P(op1);
13338
203
      d2 = Z_DVAL_P(op2);
13339
203
      goto is_smaller_double;
13340
203
    }
13341
993
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13342
57
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13343
0
      d1 = Z_DVAL_P(op1);
13344
0
      d2 = Z_DVAL_P(op2);
13345
260
is_smaller_double:
13346
260
      if (d1 < d2) {
13347
210
        goto is_smaller_true;
13348
210
      } else {
13349
50
        goto is_smaller_false;
13350
50
      }
13351
260
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13352
57
      d1 = Z_DVAL_P(op1);
13353
57
      d2 = (double)Z_LVAL_P(op2);
13354
57
      goto is_smaller_double;
13355
57
    }
13356
57
  }
13357
1.06k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13358
1.06k
}
13359
13360
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13361
325k
{
13362
325k
  USE_OPLINE
13363
325k
  zval *op1, *op2;
13364
325k
  double d1, d2;
13365
13366
325k
  op1 = EX_VAR(opline->op1.var);
13367
325k
  op2 = RT_CONSTANT(opline, opline->op2);
13368
325k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13369
    /* pass */
13370
325k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13371
310k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13372
309k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13373
309k
is_smaller_true:
13374
309k
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13375
309k
      } else {
13376
2.24k
is_smaller_false:
13377
2.24k
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13378
2.24k
      }
13379
309k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13380
1.78k
      d1 = (double)Z_LVAL_P(op1);
13381
1.78k
      d2 = Z_DVAL_P(op2);
13382
1.78k
      goto is_smaller_double;
13383
1.78k
    }
13384
310k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13385
1.13k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13386
68
      d1 = Z_DVAL_P(op1);
13387
68
      d2 = Z_DVAL_P(op2);
13388
2.91k
is_smaller_double:
13389
2.91k
      if (d1 < d2) {
13390
2.73k
        goto is_smaller_true;
13391
2.73k
      } else {
13392
188
        goto is_smaller_false;
13393
188
      }
13394
2.91k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13395
1.06k
      d1 = Z_DVAL_P(op1);
13396
1.06k
      d2 = (double)Z_LVAL_P(op2);
13397
1.06k
      goto is_smaller_double;
13398
1.06k
    }
13399
1.13k
  }
13400
325k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13401
325k
}
13402
13403
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13404
14
{
13405
14
  USE_OPLINE
13406
14
  zval *op1, *op2;
13407
14
  double d1, d2;
13408
13409
14
  op1 = EX_VAR(opline->op1.var);
13410
14
  op2 = RT_CONSTANT(opline, opline->op2);
13411
14
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13412
    /* pass */
13413
14
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13414
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13415
0
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13416
0
is_smaller_or_equal_true:
13417
0
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
13418
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
13419
0
        ZEND_VM_NEXT_OPCODE();
13420
0
      } else {
13421
0
is_smaller_or_equal_false:
13422
0
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
13423
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
13424
0
        ZEND_VM_NEXT_OPCODE();
13425
0
      }
13426
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13427
0
      d1 = (double)Z_LVAL_P(op1);
13428
0
      d2 = Z_DVAL_P(op2);
13429
0
      goto is_smaller_or_equal_double;
13430
0
    }
13431
14
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13432
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13433
0
      d1 = Z_DVAL_P(op1);
13434
0
      d2 = Z_DVAL_P(op2);
13435
0
is_smaller_or_equal_double:
13436
0
      if (d1 <= d2) {
13437
0
        goto is_smaller_or_equal_true;
13438
0
      } else {
13439
0
        goto is_smaller_or_equal_false;
13440
0
      }
13441
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13442
0
      d1 = Z_DVAL_P(op1);
13443
0
      d2 = (double)Z_LVAL_P(op2);
13444
0
      goto is_smaller_or_equal_double;
13445
0
    }
13446
0
  }
13447
14
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13448
14
}
13449
13450
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13451
3.14k
{
13452
3.14k
  USE_OPLINE
13453
3.14k
  zval *op1, *op2;
13454
3.14k
  double d1, d2;
13455
13456
3.14k
  op1 = EX_VAR(opline->op1.var);
13457
3.14k
  op2 = RT_CONSTANT(opline, opline->op2);
13458
3.14k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13459
    /* pass */
13460
3.14k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13461
539
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13462
538
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13463
474
is_smaller_or_equal_true:
13464
474
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13465
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
13466
0
        ZEND_VM_NEXT_OPCODE();
13467
124
      } else {
13468
126
is_smaller_or_equal_false:
13469
126
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13470
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
13471
0
        ZEND_VM_NEXT_OPCODE();
13472
0
      }
13473
538
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13474
1
      d1 = (double)Z_LVAL_P(op1);
13475
1
      d2 = Z_DVAL_P(op2);
13476
1
      goto is_smaller_or_equal_double;
13477
1
    }
13478
2.60k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13479
61
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13480
57
      d1 = Z_DVAL_P(op1);
13481
57
      d2 = Z_DVAL_P(op2);
13482
62
is_smaller_or_equal_double:
13483
62
      if (d1 <= d2) {
13484
60
        goto is_smaller_or_equal_true;
13485
60
      } else {
13486
2
        goto is_smaller_or_equal_false;
13487
2
      }
13488
62
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13489
4
      d1 = Z_DVAL_P(op1);
13490
4
      d2 = (double)Z_LVAL_P(op2);
13491
4
      goto is_smaller_or_equal_double;
13492
4
    }
13493
61
  }
13494
3.14k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13495
3.14k
}
13496
13497
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13498
18.8k
{
13499
18.8k
  USE_OPLINE
13500
18.8k
  zval *op1, *op2;
13501
18.8k
  double d1, d2;
13502
13503
18.8k
  op1 = EX_VAR(opline->op1.var);
13504
18.8k
  op2 = RT_CONSTANT(opline, opline->op2);
13505
18.8k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13506
    /* pass */
13507
18.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13508
15.8k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13509
11.4k
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13510
11.7k
is_smaller_or_equal_true:
13511
11.7k
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13512
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
13513
0
        ZEND_VM_NEXT_OPCODE();
13514
1.84k
      } else {
13515
3.50k
is_smaller_or_equal_false:
13516
3.50k
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13517
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
13518
0
        ZEND_VM_NEXT_OPCODE();
13519
0
      }
13520
11.4k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13521
3.67k
      d1 = (double)Z_LVAL_P(op1);
13522
3.67k
      d2 = Z_DVAL_P(op2);
13523
3.67k
      goto is_smaller_or_equal_double;
13524
3.67k
    }
13525
15.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13526
52
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13527
0
      d1 = Z_DVAL_P(op1);
13528
0
      d2 = Z_DVAL_P(op2);
13529
3.72k
is_smaller_or_equal_double:
13530
3.72k
      if (d1 <= d2) {
13531
2.05k
        goto is_smaller_or_equal_true;
13532
2.05k
      } else {
13533
1.66k
        goto is_smaller_or_equal_false;
13534
1.66k
      }
13535
3.72k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13536
52
      d1 = Z_DVAL_P(op1);
13537
52
      d2 = (double)Z_LVAL_P(op2);
13538
52
      goto is_smaller_or_equal_double;
13539
52
    }
13540
52
  }
13541
18.8k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13542
18.8k
}
13543
13544
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13545
11.9k
{
13546
11.9k
  USE_OPLINE
13547
11.9k
  zval *op1, *op2;
13548
13549
11.9k
  op1 = EX_VAR(opline->op1.var);
13550
11.9k
  op2 = RT_CONSTANT(opline, opline->op2);
13551
11.9k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13552
    /* pass */
13553
11.9k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13554
11.9k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13555
848
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
13556
848
    ZEND_VM_NEXT_OPCODE();
13557
848
  }
13558
13559
11.9k
  ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13560
11.9k
}
13561
13562
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13563
4.02k
{
13564
4.02k
  USE_OPLINE
13565
4.02k
  zval *op1, *op2;
13566
13567
4.02k
  op1 = EX_VAR(opline->op1.var);
13568
4.02k
  op2 = RT_CONSTANT(opline, opline->op2);
13569
4.02k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13570
    /* pass */
13571
4.02k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13572
4.02k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13573
1.22k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
13574
1.22k
    ZEND_VM_NEXT_OPCODE();
13575
1.22k
  }
13576
13577
4.02k
  ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13578
4.02k
}
13579
13580
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13581
27.8k
{
13582
27.8k
  USE_OPLINE
13583
27.8k
  zval *op1, *op2;
13584
13585
27.8k
  op1 = EX_VAR(opline->op1.var);
13586
27.8k
  op2 = RT_CONSTANT(opline, opline->op2);
13587
27.8k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13588
    /* pass */
13589
27.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13590
27.8k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13591
16.9k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
13592
16.9k
    ZEND_VM_NEXT_OPCODE();
13593
16.9k
  }
13594
13595
27.8k
  ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13596
27.8k
}
13597
13598
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13599
3.33k
{
13600
3.33k
  USE_OPLINE
13601
3.33k
  zval *container;
13602
13603
3.33k
  SAVE_OPLINE();
13604
3.33k
  container = EX_VAR(opline->op1.var);
13605
3.33k
  zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
13606
13607
3.33k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
13608
3.33k
}
13609
13610
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13611
5
{
13612
5
  USE_OPLINE
13613
5
  zval *op, *jump_zv;
13614
5
  HashTable *jumptable;
13615
13616
5
  op = EX_VAR(opline->op1.var);
13617
13618
5
  if (Z_TYPE_P(op) != IS_LONG) {
13619
0
    ZVAL_DEREF(op);
13620
0
    if (Z_TYPE_P(op) != IS_LONG) {
13621
      /* Wrong type, fall back to ZEND_CASE chain */
13622
0
      ZEND_VM_NEXT_OPCODE();
13623
0
    }
13624
0
  }
13625
13626
5
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13627
5
  jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13628
5
  if (jump_zv != NULL) {
13629
5
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13630
5
    ZEND_VM_CONTINUE();
13631
5
  } else {
13632
    /* default */
13633
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13634
0
    ZEND_VM_CONTINUE();
13635
0
  }
13636
5
}
13637
13638
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13639
352
{
13640
352
  USE_OPLINE
13641
352
  zval *op, *jump_zv;
13642
352
  HashTable *jumptable;
13643
13644
352
  op = EX_VAR(opline->op1.var);
13645
13646
352
  if (Z_TYPE_P(op) != IS_STRING) {
13647
31
    if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13648
      /* Wrong type, fall back to ZEND_CASE chain */
13649
0
      ZEND_VM_NEXT_OPCODE();
13650
31
    } else {
13651
31
      ZVAL_DEREF(op);
13652
31
      if (Z_TYPE_P(op) != IS_STRING) {
13653
        /* Wrong type, fall back to ZEND_CASE chain */
13654
31
        ZEND_VM_NEXT_OPCODE();
13655
31
      }
13656
31
    }
13657
31
  }
13658
13659
321
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13660
321
  jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13661
321
  if (jump_zv != NULL) {
13662
43
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13663
43
    ZEND_VM_CONTINUE();
13664
278
  } else {
13665
    /* default */
13666
278
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13667
278
    ZEND_VM_CONTINUE();
13668
278
  }
13669
321
}
13670
13671
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13672
352
{
13673
352
  USE_OPLINE
13674
352
  zval *op, *jump_zv;
13675
352
  HashTable *jumptable;
13676
13677
352
  op = EX_VAR(opline->op1.var);
13678
352
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13679
13680
367
match_try_again:
13681
367
  if (Z_TYPE_P(op) == IS_LONG) {
13682
217
    jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13683
217
  } else if (Z_TYPE_P(op) == IS_STRING) {
13684
108
    jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13685
108
  } else if (Z_TYPE_P(op) == IS_REFERENCE) {
13686
0
    op = Z_REFVAL_P(op);
13687
0
    goto match_try_again;
13688
42
  } else {
13689
42
    if (UNEXPECTED(((IS_TMP_VAR|IS_VAR|IS_CV) & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
13690
25
      SAVE_OPLINE();
13691
25
      op = ZVAL_UNDEFINED_OP1();
13692
25
      if (UNEXPECTED(EG(exception))) {
13693
10
        HANDLE_EXCEPTION();
13694
10
      }
13695
15
      goto match_try_again;
13696
25
    }
13697
13698
17
    goto default_branch;
13699
42
  }
13700
13701
325
  if (jump_zv != NULL) {
13702
191
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13703
191
    ZEND_VM_CONTINUE();
13704
191
  } else {
13705
151
default_branch:
13706
    /* default */
13707
151
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13708
151
    ZEND_VM_CONTINUE();
13709
151
  }
13710
325
}
13711
13712
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13713
1.21k
{
13714
1.21k
  USE_OPLINE
13715
1.21k
  zval *op1, *op2, *result;
13716
13717
1.21k
  op1 = EX_VAR(opline->op1.var);
13718
1.21k
  op2 = RT_CONSTANT(opline, opline->op2);
13719
1.21k
  result = EX_VAR(opline->result.var);
13720
1.21k
  ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
13721
1.21k
  ZEND_VM_NEXT_OPCODE();
13722
1.21k
}
13723
13724
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13725
611
{
13726
611
  USE_OPLINE
13727
611
  zval *op1, *op2, *result;
13728
13729
611
  op1 = EX_VAR(opline->op1.var);
13730
611
  op2 = RT_CONSTANT(opline, opline->op2);
13731
611
  result = EX_VAR(opline->result.var);
13732
611
  fast_long_add_function(result, op1, op2);
13733
611
  ZEND_VM_NEXT_OPCODE();
13734
611
}
13735
13736
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13737
201
{
13738
201
  USE_OPLINE
13739
201
  zval *op1, *op2, *result;
13740
13741
201
  op1 = EX_VAR(opline->op1.var);
13742
201
  op2 = RT_CONSTANT(opline, opline->op2);
13743
201
  result = EX_VAR(opline->result.var);
13744
201
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
13745
201
  ZEND_VM_NEXT_OPCODE();
13746
201
}
13747
13748
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13749
1.04k
{
13750
1.04k
  USE_OPLINE
13751
1.04k
  zval *op1, *op2, *result;
13752
13753
1.04k
  op1 = EX_VAR(opline->op1.var);
13754
1.04k
  op2 = RT_CONSTANT(opline, opline->op2);
13755
1.04k
  result = EX_VAR(opline->result.var);
13756
1.04k
  ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
13757
1.04k
  ZEND_VM_NEXT_OPCODE();
13758
1.04k
}
13759
13760
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13761
1.65k
{
13762
1.65k
  USE_OPLINE
13763
1.65k
  zval *op1, *op2, *result;
13764
13765
1.65k
  op1 = EX_VAR(opline->op1.var);
13766
1.65k
  op2 = RT_CONSTANT(opline, opline->op2);
13767
1.65k
  result = EX_VAR(opline->result.var);
13768
1.65k
  fast_long_sub_function(result, op1, op2);
13769
1.65k
  ZEND_VM_NEXT_OPCODE();
13770
1.65k
}
13771
13772
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13773
218
{
13774
218
  USE_OPLINE
13775
218
  zval *op1, *op2, *result;
13776
13777
218
  op1 = EX_VAR(opline->op1.var);
13778
218
  op2 = RT_CONSTANT(opline, opline->op2);
13779
218
  result = EX_VAR(opline->result.var);
13780
218
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
13781
218
  ZEND_VM_NEXT_OPCODE();
13782
218
}
13783
13784
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13785
57
{
13786
57
  USE_OPLINE
13787
57
  zval *op1, *op2, *result;
13788
13789
57
  op1 = EX_VAR(opline->op1.var);
13790
57
  op2 = RT_CONSTANT(opline, opline->op2);
13791
57
  result = EX_VAR(opline->result.var);
13792
57
  ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
13793
57
  ZEND_VM_NEXT_OPCODE();
13794
57
}
13795
13796
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13797
1.75k
{
13798
1.75k
  USE_OPLINE
13799
1.75k
  zval *op1, *op2, *result;
13800
1.75k
  zend_long overflow;
13801
13802
1.75k
  op1 = EX_VAR(opline->op1.var);
13803
1.75k
  op2 = RT_CONSTANT(opline, opline->op2);
13804
1.75k
  result = EX_VAR(opline->result.var);
13805
1.75k
  ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13806
1.75k
  Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13807
1.75k
  ZEND_VM_NEXT_OPCODE();
13808
1.75k
}
13809
13810
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13811
22
{
13812
22
  USE_OPLINE
13813
22
  zval *op1, *op2, *result;
13814
13815
22
  op1 = EX_VAR(opline->op1.var);
13816
22
  op2 = RT_CONSTANT(opline, opline->op2);
13817
22
  result = EX_VAR(opline->result.var);
13818
22
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
13819
22
  ZEND_VM_NEXT_OPCODE();
13820
22
}
13821
13822
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13823
407
{
13824
407
  USE_OPLINE
13825
407
  zval *op1, *op2;
13826
407
  bool result;
13827
13828
407
  op1 = EX_VAR(opline->op1.var);
13829
407
  op2 = RT_CONSTANT(opline, opline->op2);
13830
407
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13831
407
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13832
407
}
13833
13834
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13835
1.01k
{
13836
1.01k
  USE_OPLINE
13837
1.01k
  zval *op1, *op2;
13838
1.01k
  bool result;
13839
13840
1.01k
  op1 = EX_VAR(opline->op1.var);
13841
1.01k
  op2 = RT_CONSTANT(opline, opline->op2);
13842
1.01k
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13843
1.01k
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13844
1.01k
}
13845
13846
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13847
88
{
13848
88
  USE_OPLINE
13849
88
  zval *op1, *op2;
13850
88
  bool result;
13851
13852
88
  op1 = EX_VAR(opline->op1.var);
13853
88
  op2 = RT_CONSTANT(opline, opline->op2);
13854
88
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13855
88
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13856
88
}
13857
13858
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13859
92
{
13860
92
  USE_OPLINE
13861
92
  zval *op1, *op2;
13862
92
  bool result;
13863
13864
92
  op1 = EX_VAR(opline->op1.var);
13865
92
  op2 = RT_CONSTANT(opline, opline->op2);
13866
92
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13867
92
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13868
92
}
13869
13870
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13871
170
{
13872
170
  USE_OPLINE
13873
170
  zval *op1, *op2;
13874
170
  bool result;
13875
13876
170
  op1 = EX_VAR(opline->op1.var);
13877
170
  op2 = RT_CONSTANT(opline, opline->op2);
13878
170
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13879
170
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13880
170
}
13881
13882
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13883
0
{
13884
0
  USE_OPLINE
13885
0
  zval *op1, *op2;
13886
0
  bool result;
13887
13888
0
  op1 = EX_VAR(opline->op1.var);
13889
0
  op2 = RT_CONSTANT(opline, opline->op2);
13890
0
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13891
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13892
0
}
13893
13894
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13895
0
{
13896
0
  USE_OPLINE
13897
0
  zval *op1, *op2;
13898
0
  bool result;
13899
13900
0
  op1 = EX_VAR(opline->op1.var);
13901
0
  op2 = RT_CONSTANT(opline, opline->op2);
13902
0
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13903
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13904
0
}
13905
13906
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13907
26
{
13908
26
  USE_OPLINE
13909
26
  zval *op1, *op2;
13910
26
  bool result;
13911
13912
26
  op1 = EX_VAR(opline->op1.var);
13913
26
  op2 = RT_CONSTANT(opline, opline->op2);
13914
26
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13915
26
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13916
26
}
13917
13918
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13919
0
{
13920
0
  USE_OPLINE
13921
0
  zval *op1, *op2;
13922
0
  bool result;
13923
13924
0
  op1 = EX_VAR(opline->op1.var);
13925
0
  op2 = RT_CONSTANT(opline, opline->op2);
13926
0
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13927
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13928
0
}
13929
13930
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13931
0
{
13932
0
  USE_OPLINE
13933
0
  zval *op1, *op2;
13934
0
  bool result;
13935
13936
0
  op1 = EX_VAR(opline->op1.var);
13937
0
  op2 = RT_CONSTANT(opline, opline->op2);
13938
0
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13939
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13940
0
}
13941
13942
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13943
0
{
13944
0
  USE_OPLINE
13945
0
  zval *op1, *op2;
13946
0
  bool result;
13947
13948
0
  op1 = EX_VAR(opline->op1.var);
13949
0
  op2 = RT_CONSTANT(opline, opline->op2);
13950
0
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13951
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13952
0
}
13953
13954
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13955
0
{
13956
0
  USE_OPLINE
13957
0
  zval *op1, *op2;
13958
0
  bool result;
13959
13960
0
  op1 = EX_VAR(opline->op1.var);
13961
0
  op2 = RT_CONSTANT(opline, opline->op2);
13962
0
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13963
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13964
0
}
13965
13966
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13967
0
{
13968
0
  USE_OPLINE
13969
0
  zval *op1;
13970
0
  bool result;
13971
13972
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
13973
0
  result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0;
13974
0
  FREE_OP(opline->op1_type, opline->op1.var);
13975
13976
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13977
0
}
13978
13979
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13980
0
{
13981
0
  USE_OPLINE
13982
0
  zval *op1;
13983
0
  bool result;
13984
13985
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
13986
0
  result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0;
13987
0
  FREE_OP(opline->op1_type, opline->op1.var);
13988
13989
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13990
0
}
13991
13992
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13993
0
{
13994
0
  USE_OPLINE
13995
0
  zval *op1;
13996
0
  bool result;
13997
13998
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
13999
0
  result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0;
14000
0
  FREE_OP(opline->op1_type, opline->op1.var);
14001
14002
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14003
0
}
14004
14005
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14006
0
{
14007
0
  USE_OPLINE
14008
0
  zval *op1;
14009
0
  bool result;
14010
14011
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
14012
0
  result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0;
14013
0
  FREE_OP(opline->op1_type, opline->op1.var);
14014
14015
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14016
0
}
14017
14018
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14019
0
{
14020
0
  USE_OPLINE
14021
0
  zval *op1;
14022
0
  bool result;
14023
14024
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
14025
0
  result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0;
14026
0
  FREE_OP(opline->op1_type, opline->op1.var);
14027
14028
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14029
0
}
14030
14031
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14032
0
{
14033
0
  USE_OPLINE
14034
0
  zval *op1;
14035
0
  bool result;
14036
14037
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
14038
0
  result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0;
14039
0
  FREE_OP(opline->op1_type, opline->op1.var);
14040
14041
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14042
0
}
14043
14044
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14045
102
{
14046
102
  USE_OPLINE
14047
102
  zval *op1, *op2;
14048
102
  bool result;
14049
14050
102
  op1 = EX_VAR(opline->op1.var);
14051
102
  op2 = RT_CONSTANT(opline, opline->op2);
14052
102
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14053
102
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14054
102
}
14055
14056
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14057
959
{
14058
959
  USE_OPLINE
14059
959
  zval *op1, *op2;
14060
959
  bool result;
14061
14062
959
  op1 = EX_VAR(opline->op1.var);
14063
959
  op2 = RT_CONSTANT(opline, opline->op2);
14064
959
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14065
959
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14066
959
}
14067
14068
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14069
12.1k
{
14070
12.1k
  USE_OPLINE
14071
12.1k
  zval *op1, *op2;
14072
12.1k
  bool result;
14073
14074
12.1k
  op1 = EX_VAR(opline->op1.var);
14075
12.1k
  op2 = RT_CONSTANT(opline, opline->op2);
14076
12.1k
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14077
12.1k
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14078
12.1k
}
14079
14080
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14081
140
{
14082
140
  USE_OPLINE
14083
140
  zval *op1, *op2;
14084
140
  bool result;
14085
14086
140
  op1 = EX_VAR(opline->op1.var);
14087
140
  op2 = RT_CONSTANT(opline, opline->op2);
14088
140
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14089
140
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14090
140
}
14091
14092
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14093
0
{
14094
0
  USE_OPLINE
14095
0
  zval *op1, *op2;
14096
0
  bool result;
14097
14098
0
  op1 = EX_VAR(opline->op1.var);
14099
0
  op2 = RT_CONSTANT(opline, opline->op2);
14100
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14101
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14102
0
}
14103
14104
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14105
0
{
14106
0
  USE_OPLINE
14107
0
  zval *op1, *op2;
14108
0
  bool result;
14109
14110
0
  op1 = EX_VAR(opline->op1.var);
14111
0
  op2 = RT_CONSTANT(opline, opline->op2);
14112
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14113
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14114
0
}
14115
14116
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14117
0
{
14118
0
  USE_OPLINE
14119
0
  zval *op1, *op2;
14120
0
  bool result;
14121
14122
0
  op1 = EX_VAR(opline->op1.var);
14123
0
  op2 = RT_CONSTANT(opline, opline->op2);
14124
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14125
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14126
0
}
14127
14128
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14129
110
{
14130
110
  USE_OPLINE
14131
110
  zval *op1, *op2;
14132
110
  bool result;
14133
14134
110
  op1 = EX_VAR(opline->op1.var);
14135
110
  op2 = RT_CONSTANT(opline, opline->op2);
14136
110
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14137
110
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14138
110
}
14139
14140
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14141
2.07k
{
14142
2.07k
  USE_OPLINE
14143
2.07k
  zval *op1, *op2;
14144
2.07k
  bool result;
14145
14146
2.07k
  op1 = EX_VAR(opline->op1.var);
14147
2.07k
  op2 = RT_CONSTANT(opline, opline->op2);
14148
2.07k
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14149
2.07k
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14150
2.07k
}
14151
14152
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14153
0
{
14154
0
  USE_OPLINE
14155
0
  zval *op1, *op2;
14156
0
  bool result;
14157
14158
0
  op1 = EX_VAR(opline->op1.var);
14159
0
  op2 = RT_CONSTANT(opline, opline->op2);
14160
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14161
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14162
0
}
14163
14164
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14165
0
{
14166
0
  USE_OPLINE
14167
0
  zval *op1, *op2;
14168
0
  bool result;
14169
14170
0
  op1 = EX_VAR(opline->op1.var);
14171
0
  op2 = RT_CONSTANT(opline, opline->op2);
14172
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14173
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14174
0
}
14175
14176
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14177
0
{
14178
0
  USE_OPLINE
14179
0
  zval *op1, *op2;
14180
0
  bool result;
14181
14182
0
  op1 = EX_VAR(opline->op1.var);
14183
0
  op2 = RT_CONSTANT(opline, opline->op2);
14184
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14185
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14186
0
}
14187
14188
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14189
74.5k
{
14190
74.5k
  USE_OPLINE
14191
74.5k
  zval *op1, *op2, *result;
14192
74.5k
  double d1, d2;
14193
14194
74.5k
  op1 = EX_VAR(opline->op1.var);
14195
74.5k
  op2 = EX_VAR(opline->op2.var);
14196
74.5k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14197
    /* pass */
14198
74.5k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14199
45.6k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14200
35.5k
      result = EX_VAR(opline->result.var);
14201
35.5k
      fast_long_add_function(result, op1, op2);
14202
35.5k
      ZEND_VM_NEXT_OPCODE();
14203
35.5k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14204
1.74k
      d1 = (double)Z_LVAL_P(op1);
14205
1.74k
      d2 = Z_DVAL_P(op2);
14206
1.74k
      goto add_double;
14207
1.74k
    }
14208
45.6k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14209
12.4k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14210
7.73k
      d1 = Z_DVAL_P(op1);
14211
7.73k
      d2 = Z_DVAL_P(op2);
14212
11.5k
add_double:
14213
11.5k
      result = EX_VAR(opline->result.var);
14214
11.5k
      ZVAL_DOUBLE(result, d1 + d2);
14215
11.5k
      ZEND_VM_NEXT_OPCODE();
14216
11.5k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14217
2.04k
      d1 = Z_DVAL_P(op1);
14218
2.04k
      d2 = (double)Z_LVAL_P(op2);
14219
2.04k
      goto add_double;
14220
2.04k
    }
14221
12.4k
  }
14222
14223
74.5k
  ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14224
74.5k
}
14225
14226
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14227
6.55k
{
14228
6.55k
  USE_OPLINE
14229
6.55k
  zval *op1, *op2, *result;
14230
6.55k
  double d1, d2;
14231
14232
6.55k
  op1 = EX_VAR(opline->op1.var);
14233
6.55k
  op2 = EX_VAR(opline->op2.var);
14234
6.55k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14235
    /* pass */
14236
6.55k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14237
3.69k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14238
2.94k
      result = EX_VAR(opline->result.var);
14239
2.94k
      fast_long_sub_function(result, op1, op2);
14240
2.94k
      ZEND_VM_NEXT_OPCODE();
14241
2.94k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14242
14
      d1 = (double)Z_LVAL_P(op1);
14243
14
      d2 = Z_DVAL_P(op2);
14244
14
      goto sub_double;
14245
14
    }
14246
3.69k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14247
744
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14248
466
      d1 = Z_DVAL_P(op1);
14249
466
      d2 = Z_DVAL_P(op2);
14250
752
sub_double:
14251
752
      result = EX_VAR(opline->result.var);
14252
752
      ZVAL_DOUBLE(result, d1 - d2);
14253
752
      ZEND_VM_NEXT_OPCODE();
14254
752
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14255
272
      d1 = Z_DVAL_P(op1);
14256
272
      d2 = (double)Z_LVAL_P(op2);
14257
272
      goto sub_double;
14258
272
    }
14259
744
  }
14260
14261
6.55k
  ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14262
6.55k
}
14263
14264
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14265
7.26k
{
14266
7.26k
  USE_OPLINE
14267
7.26k
  zval *op1, *op2, *result;
14268
7.26k
  double d1, d2;
14269
14270
7.26k
  op1 = EX_VAR(opline->op1.var);
14271
7.26k
  op2 = EX_VAR(opline->op2.var);
14272
7.26k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14273
    /* pass */
14274
7.26k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14275
3.52k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14276
2.39k
      zend_long overflow;
14277
14278
2.39k
      result = EX_VAR(opline->result.var);
14279
2.39k
      ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14280
2.39k
      Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14281
2.39k
      ZEND_VM_NEXT_OPCODE();
14282
2.39k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14283
164
      d1 = (double)Z_LVAL_P(op1);
14284
164
      d2 = Z_DVAL_P(op2);
14285
164
      goto mul_double;
14286
164
    }
14287
3.73k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14288
1.48k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14289
1.40k
      d1 = Z_DVAL_P(op1);
14290
1.40k
      d2 = Z_DVAL_P(op2);
14291
1.63k
mul_double:
14292
1.63k
      result = EX_VAR(opline->result.var);
14293
1.63k
      ZVAL_DOUBLE(result, d1 * d2);
14294
1.63k
      ZEND_VM_NEXT_OPCODE();
14295
1.63k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14296
71
      d1 = Z_DVAL_P(op1);
14297
71
      d2 = (double)Z_LVAL_P(op2);
14298
71
      goto mul_double;
14299
71
    }
14300
1.48k
  }
14301
14302
7.26k
  ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14303
7.26k
}
14304
14305
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14306
3.65k
{
14307
3.65k
  USE_OPLINE
14308
3.65k
  zval *op1, *op2, *result;
14309
14310
3.65k
  op1 = EX_VAR(opline->op1.var);
14311
3.65k
  op2 = EX_VAR(opline->op2.var);
14312
3.65k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14313
    /* pass */
14314
3.65k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14315
2.68k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14316
2.63k
      result = EX_VAR(opline->result.var);
14317
2.63k
      if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
14318
44
        ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
14319
2.58k
      } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
14320
        /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
14321
31
        ZVAL_LONG(result, 0);
14322
2.55k
      } else {
14323
2.55k
        ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
14324
2.55k
      }
14325
2.58k
      ZEND_VM_NEXT_OPCODE();
14326
2.58k
    }
14327
2.68k
  }
14328
14329
3.65k
  ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14330
3.65k
}
14331
14332
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14333
821
{
14334
821
  USE_OPLINE
14335
821
  zval *op1, *op2;
14336
14337
821
  op1 = EX_VAR(opline->op1.var);
14338
821
  op2 = EX_VAR(opline->op2.var);
14339
821
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14340
    /* pass */
14341
821
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14342
821
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
14343
821
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
14344
    /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
14345
650
    ZVAL_LONG(EX_VAR(opline->result.var),
14346
650
      (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
14347
650
    ZEND_VM_NEXT_OPCODE();
14348
650
  }
14349
14350
821
  ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14351
821
}
14352
14353
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14354
642
{
14355
642
  USE_OPLINE
14356
642
  zval *op1, *op2;
14357
14358
642
  op1 = EX_VAR(opline->op1.var);
14359
642
  op2 = EX_VAR(opline->op2.var);
14360
642
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14361
    /* pass */
14362
642
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14363
642
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
14364
642
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
14365
370
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
14366
370
    ZEND_VM_NEXT_OPCODE();
14367
370
  }
14368
14369
642
  ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14370
642
}
14371
14372
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14373
26.1k
{
14374
26.1k
  USE_OPLINE
14375
26.1k
  zval *op1, *op2;
14376
26.1k
  double d1, d2;
14377
14378
26.1k
  op1 = EX_VAR(opline->op1.var);
14379
26.1k
  op2 = EX_VAR(opline->op2.var);
14380
26.1k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14381
    /* pass */
14382
26.1k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14383
2.46k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14384
1.42k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14385
345
is_smaller_true:
14386
345
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
14387
1.17k
      } else {
14388
1.39k
is_smaller_false:
14389
1.39k
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
14390
1.39k
      }
14391
1.42k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14392
86
      d1 = (double)Z_LVAL_P(op1);
14393
86
      d2 = Z_DVAL_P(op2);
14394
86
      goto is_smaller_double;
14395
86
    }
14396
23.6k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14397
300
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14398
200
      d1 = Z_DVAL_P(op1);
14399
200
      d2 = Z_DVAL_P(op2);
14400
308
is_smaller_double:
14401
308
      if (d1 < d2) {
14402
88
        goto is_smaller_true;
14403
220
      } else {
14404
220
        goto is_smaller_false;
14405
220
      }
14406
308
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14407
22
      d1 = Z_DVAL_P(op1);
14408
22
      d2 = (double)Z_LVAL_P(op2);
14409
22
      goto is_smaller_double;
14410
22
    }
14411
300
  }
14412
26.1k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14413
26.1k
}
14414
14415
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14416
184
{
14417
184
  USE_OPLINE
14418
184
  zval *op1, *op2;
14419
184
  double d1, d2;
14420
14421
184
  op1 = EX_VAR(opline->op1.var);
14422
184
  op2 = EX_VAR(opline->op2.var);
14423
184
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14424
    /* pass */
14425
184
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14426
30
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14427
0
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14428
2
is_smaller_true:
14429
2
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
14430
2
      } else {
14431
72
is_smaller_false:
14432
72
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
14433
72
      }
14434
30
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14435
18
      d1 = (double)Z_LVAL_P(op1);
14436
18
      d2 = Z_DVAL_P(op2);
14437
18
      goto is_smaller_double;
14438
18
    }
14439
154
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14440
61
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14441
38
      d1 = Z_DVAL_P(op1);
14442
38
      d2 = Z_DVAL_P(op2);
14443
74
is_smaller_double:
14444
74
      if (d1 < d2) {
14445
2
        goto is_smaller_true;
14446
72
      } else {
14447
72
        goto is_smaller_false;
14448
72
      }
14449
74
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14450
18
      d1 = Z_DVAL_P(op1);
14451
18
      d2 = (double)Z_LVAL_P(op2);
14452
18
      goto is_smaller_double;
14453
18
    }
14454
61
  }
14455
184
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14456
184
}
14457
14458
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14459
11.5k
{
14460
11.5k
  USE_OPLINE
14461
11.5k
  zval *op1, *op2;
14462
11.5k
  double d1, d2;
14463
14464
11.5k
  op1 = EX_VAR(opline->op1.var);
14465
11.5k
  op2 = EX_VAR(opline->op2.var);
14466
11.5k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14467
    /* pass */
14468
11.5k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14469
10.8k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14470
10.6k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14471
10.3k
is_smaller_true:
14472
10.3k
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14473
10.3k
      } else {
14474
559
is_smaller_false:
14475
559
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14476
559
      }
14477
10.6k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14478
174
      d1 = (double)Z_LVAL_P(op1);
14479
174
      d2 = Z_DVAL_P(op2);
14480
174
      goto is_smaller_double;
14481
174
    }
14482
10.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14483
163
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14484
26
      d1 = Z_DVAL_P(op1);
14485
26
      d2 = Z_DVAL_P(op2);
14486
337
is_smaller_double:
14487
337
      if (d1 < d2) {
14488
290
        goto is_smaller_true;
14489
290
      } else {
14490
47
        goto is_smaller_false;
14491
47
      }
14492
337
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14493
137
      d1 = Z_DVAL_P(op1);
14494
137
      d2 = (double)Z_LVAL_P(op2);
14495
137
      goto is_smaller_double;
14496
137
    }
14497
163
  }
14498
11.5k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14499
11.5k
}
14500
14501
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14502
21.1k
{
14503
21.1k
  USE_OPLINE
14504
21.1k
  zval *op1, *op2;
14505
21.1k
  double d1, d2;
14506
14507
21.1k
  op1 = EX_VAR(opline->op1.var);
14508
21.1k
  op2 = EX_VAR(opline->op2.var);
14509
21.1k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14510
    /* pass */
14511
21.1k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14512
119
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14513
95
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14514
26
is_smaller_or_equal_true:
14515
26
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
14516
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
14517
0
        ZEND_VM_NEXT_OPCODE();
14518
84
      } else {
14519
167
is_smaller_or_equal_false:
14520
167
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
14521
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
14522
0
        ZEND_VM_NEXT_OPCODE();
14523
0
      }
14524
95
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14525
20
      d1 = (double)Z_LVAL_P(op1);
14526
20
      d2 = Z_DVAL_P(op2);
14527
20
      goto is_smaller_or_equal_double;
14528
20
    }
14529
21.0k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14530
84
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14531
58
      d1 = Z_DVAL_P(op1);
14532
58
      d2 = Z_DVAL_P(op2);
14533
98
is_smaller_or_equal_double:
14534
98
      if (d1 <= d2) {
14535
15
        goto is_smaller_or_equal_true;
14536
83
      } else {
14537
83
        goto is_smaller_or_equal_false;
14538
83
      }
14539
98
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14540
20
      d1 = Z_DVAL_P(op1);
14541
20
      d2 = (double)Z_LVAL_P(op2);
14542
20
      goto is_smaller_or_equal_double;
14543
20
    }
14544
84
  }
14545
21.1k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14546
21.1k
}
14547
14548
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14549
449
{
14550
449
  USE_OPLINE
14551
449
  zval *op1, *op2;
14552
449
  double d1, d2;
14553
14554
449
  op1 = EX_VAR(opline->op1.var);
14555
449
  op2 = EX_VAR(opline->op2.var);
14556
449
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14557
    /* pass */
14558
449
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14559
201
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14560
168
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14561
162
is_smaller_or_equal_true:
14562
162
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
14563
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
14564
0
        ZEND_VM_NEXT_OPCODE();
14565
18
      } else {
14566
80
is_smaller_or_equal_false:
14567
80
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
14568
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
14569
0
        ZEND_VM_NEXT_OPCODE();
14570
0
      }
14571
168
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14572
18
      d1 = (double)Z_LVAL_P(op1);
14573
18
      d2 = Z_DVAL_P(op2);
14574
18
      goto is_smaller_or_equal_double;
14575
18
    }
14576
248
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14577
60
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14578
40
      d1 = Z_DVAL_P(op1);
14579
40
      d2 = Z_DVAL_P(op2);
14580
74
is_smaller_or_equal_double:
14581
74
      if (d1 <= d2) {
14582
12
        goto is_smaller_or_equal_true;
14583
62
      } else {
14584
62
        goto is_smaller_or_equal_false;
14585
62
      }
14586
74
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14587
16
      d1 = Z_DVAL_P(op1);
14588
16
      d2 = (double)Z_LVAL_P(op2);
14589
16
      goto is_smaller_or_equal_double;
14590
16
    }
14591
60
  }
14592
449
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14593
449
}
14594
14595
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14596
1.72k
{
14597
1.72k
  USE_OPLINE
14598
1.72k
  zval *op1, *op2;
14599
1.72k
  double d1, d2;
14600
14601
1.72k
  op1 = EX_VAR(opline->op1.var);
14602
1.72k
  op2 = EX_VAR(opline->op2.var);
14603
1.72k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14604
    /* pass */
14605
1.72k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14606
728
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14607
392
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14608
535
is_smaller_or_equal_true:
14609
535
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14610
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
14611
0
        ZEND_VM_NEXT_OPCODE();
14612
178
      } else {
14613
224
is_smaller_or_equal_false:
14614
224
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14615
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
14616
0
        ZEND_VM_NEXT_OPCODE();
14617
0
      }
14618
392
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14619
336
      d1 = (double)Z_LVAL_P(op1);
14620
336
      d2 = Z_DVAL_P(op2);
14621
336
      goto is_smaller_or_equal_double;
14622
336
    }
14623
993
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14624
33
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14625
24
      d1 = Z_DVAL_P(op1);
14626
24
      d2 = Z_DVAL_P(op2);
14627
367
is_smaller_or_equal_double:
14628
367
      if (d1 <= d2) {
14629
321
        goto is_smaller_or_equal_true;
14630
321
      } else {
14631
46
        goto is_smaller_or_equal_false;
14632
46
      }
14633
367
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14634
7
      d1 = Z_DVAL_P(op1);
14635
7
      d2 = (double)Z_LVAL_P(op2);
14636
7
      goto is_smaller_or_equal_double;
14637
7
    }
14638
33
  }
14639
1.72k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14640
1.72k
}
14641
14642
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14643
1.93k
{
14644
1.93k
  USE_OPLINE
14645
1.93k
  zval *op1, *op2;
14646
14647
1.93k
  op1 = EX_VAR(opline->op1.var);
14648
1.93k
  op2 = EX_VAR(opline->op2.var);
14649
1.93k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14650
    /* pass */
14651
1.93k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14652
1.93k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14653
253
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
14654
253
    ZEND_VM_NEXT_OPCODE();
14655
253
  }
14656
14657
1.93k
  ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14658
1.93k
}
14659
14660
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14661
124k
{
14662
124k
  USE_OPLINE
14663
124k
  zval *op1, *op2;
14664
14665
124k
  op1 = EX_VAR(opline->op1.var);
14666
124k
  op2 = EX_VAR(opline->op2.var);
14667
124k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14668
    /* pass */
14669
124k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14670
124k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14671
5.67k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
14672
5.67k
    ZEND_VM_NEXT_OPCODE();
14673
5.67k
  }
14674
14675
124k
  ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14676
124k
}
14677
14678
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14679
68.9k
{
14680
68.9k
  USE_OPLINE
14681
68.9k
  zval *op1, *op2;
14682
14683
68.9k
  op1 = EX_VAR(opline->op1.var);
14684
68.9k
  op2 = EX_VAR(opline->op2.var);
14685
68.9k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14686
    /* pass */
14687
68.9k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14688
68.9k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14689
15
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
14690
15
    ZEND_VM_NEXT_OPCODE();
14691
15
  }
14692
14693
68.9k
  ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14694
68.9k
}
14695
14696
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14697
0
{
14698
0
  USE_OPLINE
14699
0
  zval *op1, *op2, *result;
14700
14701
0
  op1 = EX_VAR(opline->op1.var);
14702
0
  op2 = EX_VAR(opline->op2.var);
14703
0
  result = EX_VAR(opline->result.var);
14704
0
  ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
14705
0
  ZEND_VM_NEXT_OPCODE();
14706
0
}
14707
14708
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14709
1.87k
{
14710
1.87k
  USE_OPLINE
14711
1.87k
  zval *op1, *op2, *result;
14712
14713
1.87k
  op1 = EX_VAR(opline->op1.var);
14714
1.87k
  op2 = EX_VAR(opline->op2.var);
14715
1.87k
  result = EX_VAR(opline->result.var);
14716
1.87k
  fast_long_add_function(result, op1, op2);
14717
1.87k
  ZEND_VM_NEXT_OPCODE();
14718
1.87k
}
14719
14720
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14721
110
{
14722
110
  USE_OPLINE
14723
110
  zval *op1, *op2, *result;
14724
14725
110
  op1 = EX_VAR(opline->op1.var);
14726
110
  op2 = EX_VAR(opline->op2.var);
14727
110
  result = EX_VAR(opline->result.var);
14728
110
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
14729
110
  ZEND_VM_NEXT_OPCODE();
14730
110
}
14731
14732
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14733
0
{
14734
0
  USE_OPLINE
14735
0
  zval *op1, *op2, *result;
14736
14737
0
  op1 = EX_VAR(opline->op1.var);
14738
0
  op2 = EX_VAR(opline->op2.var);
14739
0
  result = EX_VAR(opline->result.var);
14740
0
  ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
14741
0
  ZEND_VM_NEXT_OPCODE();
14742
0
}
14743
14744
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14745
5
{
14746
5
  USE_OPLINE
14747
5
  zval *op1, *op2, *result;
14748
14749
5
  op1 = EX_VAR(opline->op1.var);
14750
5
  op2 = EX_VAR(opline->op2.var);
14751
5
  result = EX_VAR(opline->result.var);
14752
5
  fast_long_sub_function(result, op1, op2);
14753
5
  ZEND_VM_NEXT_OPCODE();
14754
5
}
14755
14756
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14757
0
{
14758
0
  USE_OPLINE
14759
0
  zval *op1, *op2, *result;
14760
14761
0
  op1 = EX_VAR(opline->op1.var);
14762
0
  op2 = EX_VAR(opline->op2.var);
14763
0
  result = EX_VAR(opline->result.var);
14764
0
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
14765
0
  ZEND_VM_NEXT_OPCODE();
14766
0
}
14767
14768
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14769
0
{
14770
0
  USE_OPLINE
14771
0
  zval *op1, *op2, *result;
14772
14773
0
  op1 = EX_VAR(opline->op1.var);
14774
0
  op2 = EX_VAR(opline->op2.var);
14775
0
  result = EX_VAR(opline->result.var);
14776
0
  ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
14777
0
  ZEND_VM_NEXT_OPCODE();
14778
0
}
14779
14780
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14781
85
{
14782
85
  USE_OPLINE
14783
85
  zval *op1, *op2, *result;
14784
85
  zend_long overflow;
14785
14786
85
  op1 = EX_VAR(opline->op1.var);
14787
85
  op2 = EX_VAR(opline->op2.var);
14788
85
  result = EX_VAR(opline->result.var);
14789
85
  ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14790
85
  Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14791
85
  ZEND_VM_NEXT_OPCODE();
14792
85
}
14793
14794
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14795
0
{
14796
0
  USE_OPLINE
14797
0
  zval *op1, *op2, *result;
14798
14799
0
  op1 = EX_VAR(opline->op1.var);
14800
0
  op2 = EX_VAR(opline->op2.var);
14801
0
  result = EX_VAR(opline->result.var);
14802
0
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
14803
0
  ZEND_VM_NEXT_OPCODE();
14804
0
}
14805
14806
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14807
0
{
14808
0
  USE_OPLINE
14809
0
  zval *op1, *op2;
14810
0
  bool result;
14811
14812
0
  op1 = EX_VAR(opline->op1.var);
14813
0
  op2 = EX_VAR(opline->op2.var);
14814
0
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14815
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14816
0
}
14817
14818
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14819
0
{
14820
0
  USE_OPLINE
14821
0
  zval *op1, *op2;
14822
0
  bool result;
14823
14824
0
  op1 = EX_VAR(opline->op1.var);
14825
0
  op2 = EX_VAR(opline->op2.var);
14826
0
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14827
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14828
0
}
14829
14830
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14831
0
{
14832
0
  USE_OPLINE
14833
0
  zval *op1, *op2;
14834
0
  bool result;
14835
14836
0
  op1 = EX_VAR(opline->op1.var);
14837
0
  op2 = EX_VAR(opline->op2.var);
14838
0
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14839
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14840
0
}
14841
14842
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14843
127
{
14844
127
  USE_OPLINE
14845
127
  zval *op1, *op2;
14846
127
  bool result;
14847
14848
127
  op1 = EX_VAR(opline->op1.var);
14849
127
  op2 = EX_VAR(opline->op2.var);
14850
127
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14851
127
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14852
127
}
14853
14854
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14855
68
{
14856
68
  USE_OPLINE
14857
68
  zval *op1, *op2;
14858
68
  bool result;
14859
14860
68
  op1 = EX_VAR(opline->op1.var);
14861
68
  op2 = EX_VAR(opline->op2.var);
14862
68
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14863
68
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14864
68
}
14865
14866
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14867
64
{
14868
64
  USE_OPLINE
14869
64
  zval *op1, *op2;
14870
64
  bool result;
14871
14872
64
  op1 = EX_VAR(opline->op1.var);
14873
64
  op2 = EX_VAR(opline->op2.var);
14874
64
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14875
64
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14876
64
}
14877
14878
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14879
0
{
14880
0
  USE_OPLINE
14881
0
  zval *op1, *op2;
14882
0
  bool result;
14883
14884
0
  op1 = EX_VAR(opline->op1.var);
14885
0
  op2 = EX_VAR(opline->op2.var);
14886
0
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14887
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14888
0
}
14889
14890
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14891
0
{
14892
0
  USE_OPLINE
14893
0
  zval *op1, *op2;
14894
0
  bool result;
14895
14896
0
  op1 = EX_VAR(opline->op1.var);
14897
0
  op2 = EX_VAR(opline->op2.var);
14898
0
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14899
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14900
0
}
14901
14902
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14903
21
{
14904
21
  USE_OPLINE
14905
21
  zval *op1, *op2;
14906
21
  bool result;
14907
14908
21
  op1 = EX_VAR(opline->op1.var);
14909
21
  op2 = EX_VAR(opline->op2.var);
14910
21
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14911
21
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14912
21
}
14913
14914
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14915
151
{
14916
151
  USE_OPLINE
14917
151
  zval *op1, *op2;
14918
151
  bool result;
14919
14920
151
  op1 = EX_VAR(opline->op1.var);
14921
151
  op2 = EX_VAR(opline->op2.var);
14922
151
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14923
151
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14924
151
}
14925
14926
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14927
62
{
14928
62
  USE_OPLINE
14929
62
  zval *op1, *op2;
14930
62
  bool result;
14931
14932
62
  op1 = EX_VAR(opline->op1.var);
14933
62
  op2 = EX_VAR(opline->op2.var);
14934
62
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14935
62
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14936
62
}
14937
14938
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14939
64
{
14940
64
  USE_OPLINE
14941
64
  zval *op1, *op2;
14942
64
  bool result;
14943
14944
64
  op1 = EX_VAR(opline->op1.var);
14945
64
  op2 = EX_VAR(opline->op2.var);
14946
64
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14947
64
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14948
64
}
14949
14950
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14951
233
{
14952
233
  USE_OPLINE
14953
233
  zval *op1, *op2;
14954
233
  bool result;
14955
14956
233
  op1 = EX_VAR(opline->op1.var);
14957
233
  op2 = EX_VAR(opline->op2.var);
14958
233
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14959
233
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14960
233
}
14961
14962
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14963
0
{
14964
0
  USE_OPLINE
14965
0
  zval *op1, *op2;
14966
0
  bool result;
14967
14968
0
  op1 = EX_VAR(opline->op1.var);
14969
0
  op2 = EX_VAR(opline->op2.var);
14970
0
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14971
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14972
0
}
14973
14974
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14975
733
{
14976
733
  USE_OPLINE
14977
733
  zval *op1, *op2;
14978
733
  bool result;
14979
14980
733
  op1 = EX_VAR(opline->op1.var);
14981
733
  op2 = EX_VAR(opline->op2.var);
14982
733
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14983
733
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14984
733
}
14985
14986
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14987
2
{
14988
2
  USE_OPLINE
14989
2
  zval *op1, *op2;
14990
2
  bool result;
14991
14992
2
  op1 = EX_VAR(opline->op1.var);
14993
2
  op2 = EX_VAR(opline->op2.var);
14994
2
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14995
2
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14996
2
}
14997
14998
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14999
0
{
15000
0
  USE_OPLINE
15001
0
  zval *op1, *op2;
15002
0
  bool result;
15003
15004
0
  op1 = EX_VAR(opline->op1.var);
15005
0
  op2 = EX_VAR(opline->op2.var);
15006
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
15007
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
15008
0
}
15009
15010
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15011
0
{
15012
0
  USE_OPLINE
15013
0
  zval *op1, *op2;
15014
0
  bool result;
15015
15016
0
  op1 = EX_VAR(opline->op1.var);
15017
0
  op2 = EX_VAR(opline->op2.var);
15018
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
15019
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
15020
0
}
15021
15022
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15023
0
{
15024
0
  USE_OPLINE
15025
0
  zval *op1, *op2;
15026
0
  bool result;
15027
15028
0
  op1 = EX_VAR(opline->op1.var);
15029
0
  op2 = EX_VAR(opline->op2.var);
15030
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
15031
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
15032
0
}
15033
15034
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15035
0
{
15036
0
  USE_OPLINE
15037
0
  zval *op1, *op2;
15038
0
  bool result;
15039
15040
0
  op1 = EX_VAR(opline->op1.var);
15041
0
  op2 = EX_VAR(opline->op2.var);
15042
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
15043
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
15044
0
}
15045
15046
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15047
0
{
15048
0
  USE_OPLINE
15049
0
  zval *op1, *op2;
15050
0
  bool result;
15051
15052
0
  op1 = EX_VAR(opline->op1.var);
15053
0
  op2 = EX_VAR(opline->op2.var);
15054
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
15055
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
15056
0
}
15057
15058
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15059
0
{
15060
0
  USE_OPLINE
15061
0
  zval *op1, *op2;
15062
0
  bool result;
15063
15064
0
  op1 = EX_VAR(opline->op1.var);
15065
0
  op2 = EX_VAR(opline->op2.var);
15066
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
15067
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
15068
0
}
15069
15070
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15071
0
{
15072
0
  USE_OPLINE
15073
0
  zval *op1, *op2;
15074
0
  bool result;
15075
15076
0
  op1 = EX_VAR(opline->op1.var);
15077
0
  op2 = EX_VAR(opline->op2.var);
15078
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
15079
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
15080
0
}
15081
15082
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15083
0
{
15084
0
  USE_OPLINE
15085
0
  zval *op1, *op2;
15086
0
  bool result;
15087
15088
0
  op1 = EX_VAR(opline->op1.var);
15089
0
  op2 = EX_VAR(opline->op2.var);
15090
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
15091
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
15092
0
}
15093
15094
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15095
24
{
15096
24
  USE_OPLINE
15097
24
  zval *container;
15098
15099
24
  SAVE_OPLINE();
15100
24
  container = EX_VAR(opline->op1.var);
15101
24
  zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
15102
24
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
15103
24
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15104
24
}
15105
15106
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15107
118
{
15108
118
  USE_OPLINE
15109
118
  zval *op;
15110
15111
118
  SAVE_OPLINE();
15112
118
  op = EX_VAR(opline->op1.var);
15113
118
  zend_match_unhandled_error(op);
15114
118
  HANDLE_EXCEPTION();
15115
118
}
15116
15117
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15118
25
{
15119
25
  USE_OPLINE
15120
25
  zval *container;
15121
15122
25
  SAVE_OPLINE();
15123
25
  container = EX_VAR(opline->op1.var);
15124
25
  zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
15125
15126
25
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15127
25
}
15128
15129
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15130
7.42k
{
15131
7.42k
  USE_OPLINE
15132
7.42k
  zval *val;
15133
15134
7.42k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15135
7.42k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15136
624
    ZVAL_FALSE(EX_VAR(opline->result.var));
15137
6.79k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15138
    /* The result and op1 can be the same cv zval */
15139
491
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
15140
491
    ZVAL_TRUE(EX_VAR(opline->result.var));
15141
491
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
15142
0
      SAVE_OPLINE();
15143
0
      ZVAL_UNDEFINED_OP1();
15144
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15145
0
    }
15146
6.30k
  } else {
15147
6.30k
    SAVE_OPLINE();
15148
6.30k
    ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
15149
6.30k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15150
6.30k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15151
6.30k
  }
15152
1.11k
  ZEND_VM_NEXT_OPCODE();
15153
1.11k
}
15154
15155
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15156
167k
{
15157
167k
  USE_OPLINE
15158
167k
  zval *z;
15159
15160
167k
  SAVE_OPLINE();
15161
167k
  z = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15162
15163
167k
  if (Z_TYPE_P(z) == IS_STRING) {
15164
166k
    zend_string *str = Z_STR_P(z);
15165
15166
166k
    if (ZSTR_LEN(str) != 0) {
15167
166k
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
15168
166k
    }
15169
166k
  } else {
15170
1.28k
    zend_string *str = zval_get_string_func(z);
15171
15172
1.28k
    if (ZSTR_LEN(str) != 0) {
15173
1.04k
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
15174
1.04k
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
15175
0
      ZVAL_UNDEFINED_OP1();
15176
0
    }
15177
1.28k
    zend_string_release_ex(str, 0);
15178
1.28k
  }
15179
15180
167k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15181
167k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15182
167k
}
15183
15184
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15185
1.74k
{
15186
1.74k
  USE_OPLINE
15187
1.74k
  zval *val;
15188
1.74k
  uint8_t op1_type;
15189
15190
1.74k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15191
15192
1.74k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15193
422
    ZEND_VM_NEXT_OPCODE();
15194
1.32k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15195
958
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15196
0
      SAVE_OPLINE();
15197
0
      ZVAL_UNDEFINED_OP1();
15198
0
      if (UNEXPECTED(EG(exception))) {
15199
0
        HANDLE_EXCEPTION();
15200
0
      }
15201
0
    }
15202
958
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15203
958
  }
15204
15205
1.74k
  SAVE_OPLINE();
15206
369
  op1_type = (IS_TMP_VAR|IS_VAR);
15207
369
  if (i_zend_is_true(val)) {
15208
252
    opline++;
15209
252
  } else {
15210
117
    opline = OP_JMP_ADDR(opline, opline->op2);
15211
117
  }
15212
369
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
15213
369
    zval_ptr_dtor_nogc(val);
15214
369
  }
15215
369
  ZEND_VM_JMP(opline);
15216
369
}
15217
15218
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15219
55.3k
{
15220
55.3k
  USE_OPLINE
15221
55.3k
  zval *val;
15222
55.3k
  uint8_t op1_type;
15223
15224
55.3k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15225
15226
55.3k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15227
2.84k
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15228
52.5k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15229
493
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15230
0
      SAVE_OPLINE();
15231
0
      ZVAL_UNDEFINED_OP1();
15232
0
      if (UNEXPECTED(EG(exception))) {
15233
0
        HANDLE_EXCEPTION();
15234
0
      }
15235
0
    }
15236
493
    ZEND_VM_NEXT_OPCODE();
15237
493
  }
15238
15239
55.3k
  SAVE_OPLINE();
15240
52.0k
  op1_type = (IS_TMP_VAR|IS_VAR);
15241
52.0k
  if (i_zend_is_true(val)) {
15242
51.0k
    opline = OP_JMP_ADDR(opline, opline->op2);
15243
51.0k
  } else {
15244
982
    opline++;
15245
982
  }
15246
52.0k
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
15247
52.0k
    zval_ptr_dtor_nogc(val);
15248
52.0k
  }
15249
52.0k
  ZEND_VM_JMP(opline);
15250
52.0k
}
15251
15252
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15253
1.48k
{
15254
1.48k
  USE_OPLINE
15255
1.48k
  zval *val;
15256
1.48k
  bool ret;
15257
15258
1.48k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15259
15260
1.48k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15261
377
    ZVAL_TRUE(EX_VAR(opline->result.var));
15262
377
    ZEND_VM_NEXT_OPCODE();
15263
1.10k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15264
165
    ZVAL_FALSE(EX_VAR(opline->result.var));
15265
165
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15266
0
      SAVE_OPLINE();
15267
0
      ZVAL_UNDEFINED_OP1();
15268
0
      if (UNEXPECTED(EG(exception))) {
15269
0
        HANDLE_EXCEPTION();
15270
0
      }
15271
0
    }
15272
165
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15273
165
  }
15274
15275
1.48k
  SAVE_OPLINE();
15276
944
  ret = i_zend_is_true(val);
15277
944
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15278
944
  if (ret) {
15279
944
    ZVAL_TRUE(EX_VAR(opline->result.var));
15280
944
    opline++;
15281
944
  } else {
15282
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
15283
0
    opline = OP_JMP_ADDR(opline, opline->op2);
15284
0
  }
15285
944
  ZEND_VM_JMP(opline);
15286
944
}
15287
15288
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15289
1.39k
{
15290
1.39k
  USE_OPLINE
15291
1.39k
  zval *val;
15292
1.39k
  bool ret;
15293
15294
1.39k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15295
15296
1.39k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15297
243
    ZVAL_TRUE(EX_VAR(opline->result.var));
15298
243
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15299
1.14k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15300
166
    ZVAL_FALSE(EX_VAR(opline->result.var));
15301
166
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15302
0
      SAVE_OPLINE();
15303
0
      ZVAL_UNDEFINED_OP1();
15304
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15305
166
    } else {
15306
166
      ZEND_VM_NEXT_OPCODE();
15307
166
    }
15308
166
  }
15309
15310
1.39k
  SAVE_OPLINE();
15311
982
  ret = i_zend_is_true(val);
15312
982
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15313
982
  if (ret) {
15314
982
    ZVAL_TRUE(EX_VAR(opline->result.var));
15315
982
    opline = OP_JMP_ADDR(opline, opline->op2);
15316
982
  } else {
15317
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
15318
0
    opline++;
15319
0
  }
15320
982
  ZEND_VM_JMP(opline);
15321
982
}
15322
15323
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15324
50.6k
{
15325
50.6k
  USE_OPLINE
15326
15327
50.6k
  SAVE_OPLINE();
15328
50.6k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15329
50.6k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15330
50.6k
}
15331
15332
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15333
15.0k
{
15334
15.0k
  zval *var;
15335
15.0k
  USE_OPLINE
15336
15337
15.0k
  var = EX_VAR(opline->op1.var);
15338
15.0k
  if (Z_TYPE_P(var) != IS_ARRAY) {
15339
4.55k
    SAVE_OPLINE();
15340
4.55k
    if (Z_FE_ITER_P(var) != (uint32_t)-1) {
15341
1.11k
      zend_hash_iterator_del(Z_FE_ITER_P(var));
15342
1.11k
    }
15343
4.55k
    zval_ptr_dtor_nogc(var);
15344
4.55k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15345
4.55k
  }
15346
15347
  /* This is freeing an array. Use an inlined version of zval_ptr_dtor_nogc. */
15348
  /* PHP only needs to save the opline and check for an exception if the last reference to the array was garbage collected (destructors of elements in the array could throw an exception) */
15349
10.5k
  if (Z_REFCOUNTED_P(var) && !Z_DELREF_P(var)) {
15350
478
    SAVE_OPLINE();
15351
478
    rc_dtor_func(Z_COUNTED_P(var));
15352
478
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15353
478
  }
15354
10.0k
  ZEND_VM_NEXT_OPCODE();
15355
10.0k
}
15356
15357
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15358
3.34k
{
15359
3.34k
  USE_OPLINE
15360
3.34k
  zval *value;
15361
15362
3.34k
  SAVE_OPLINE();
15363
3.34k
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15364
15365
3.34k
  do {
15366
3.34k
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
15367
6
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
15368
0
        value = Z_REFVAL_P(value);
15369
0
        if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
15370
0
          break;
15371
0
        }
15372
0
      }
15373
6
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15374
0
        ZVAL_UNDEFINED_OP1();
15375
0
        if (UNEXPECTED(EG(exception) != NULL)) {
15376
0
          HANDLE_EXCEPTION();
15377
0
        }
15378
0
      }
15379
6
      zend_throw_error(NULL, "Can only throw objects");
15380
6
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15381
6
      HANDLE_EXCEPTION();
15382
6
    }
15383
3.34k
  } while (0);
15384
15385
3.33k
  zend_exception_save();
15386
3.33k
  Z_TRY_ADDREF_P(value);
15387
3.33k
  zend_throw_exception_object(value);
15388
3.33k
  zend_exception_restore();
15389
3.33k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15390
3.33k
  HANDLE_EXCEPTION();
15391
3.33k
}
15392
15393
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15394
2.27k
{
15395
2.27k
  USE_OPLINE
15396
2.27k
  zval *val;
15397
15398
2.27k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15399
2.27k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15400
38
    ZVAL_TRUE(EX_VAR(opline->result.var));
15401
2.23k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15402
    /* The result and op1 can be the same cv zval */
15403
92
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
15404
92
    ZVAL_FALSE(EX_VAR(opline->result.var));
15405
92
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
15406
0
      SAVE_OPLINE();
15407
0
      ZVAL_UNDEFINED_OP1();
15408
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15409
0
    }
15410
2.14k
  } else {
15411
2.14k
    SAVE_OPLINE();
15412
2.14k
    ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
15413
2.14k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15414
2.14k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15415
2.14k
  }
15416
130
  ZEND_VM_NEXT_OPCODE();
15417
130
}
15418
15419
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15420
231
{
15421
231
  USE_OPLINE
15422
231
  zval *obj;
15423
231
  zend_object *zobj;
15424
231
  zend_class_entry *ce, *scope;
15425
231
  zend_function *clone;
15426
231
  zend_object_clone_obj_t clone_call;
15427
15428
231
  SAVE_OPLINE();
15429
231
  obj = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15430
15431
231
  do {
15432
231
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
15433
231
        ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
15434
4
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
15435
0
        obj = Z_REFVAL_P(obj);
15436
0
        if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
15437
0
          break;
15438
0
        }
15439
0
      }
15440
4
      ZVAL_UNDEF(EX_VAR(opline->result.var));
15441
4
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
15442
0
        ZVAL_UNDEFINED_OP1();
15443
0
        if (UNEXPECTED(EG(exception) != NULL)) {
15444
0
          HANDLE_EXCEPTION();
15445
0
        }
15446
0
      }
15447
4
      zend_throw_error(NULL, "__clone method called on non-object");
15448
4
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15449
4
      HANDLE_EXCEPTION();
15450
4
    }
15451
231
  } while (0);
15452
15453
227
  zobj = Z_OBJ_P(obj);
15454
227
  ce = zobj->ce;
15455
227
  clone = ce->clone;
15456
227
  clone_call = zobj->handlers->clone_obj;
15457
227
  if (UNEXPECTED(clone_call == NULL)) {
15458
5
    zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
15459
5
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15460
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
15461
5
    HANDLE_EXCEPTION();
15462
5
  }
15463
15464
222
  if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
15465
10
    scope = EX(func)->op_array.scope;
15466
10
    if (clone->common.scope != scope) {
15467
0
      if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
15468
0
       || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
15469
0
        zend_wrong_clone_call(clone, scope);
15470
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15471
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
15472
0
        HANDLE_EXCEPTION();
15473
0
      }
15474
0
    }
15475
10
  }
15476
15477
222
  ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
15478
15479
222
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15480
222
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15481
222
}
15482
15483
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15484
918
{
15485
918
  USE_OPLINE
15486
918
  zend_op_array *new_op_array;
15487
918
  zval *inc_filename;
15488
15489
918
  SAVE_OPLINE();
15490
918
  inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15491
918
  new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
15492
918
  if (UNEXPECTED(EG(exception) != NULL)) {
15493
40
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15494
40
    if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
15495
0
      destroy_op_array(new_op_array);
15496
0
      efree_size(new_op_array, sizeof(zend_op_array));
15497
0
    }
15498
40
    UNDEF_RESULT();
15499
40
    HANDLE_EXCEPTION();
15500
878
  } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
15501
0
    if (RETURN_VALUE_USED(opline)) {
15502
0
      ZVAL_TRUE(EX_VAR(opline->result.var));
15503
0
    }
15504
878
  } else if (UNEXPECTED(new_op_array == NULL)) {
15505
2
    if (RETURN_VALUE_USED(opline)) {
15506
0
      ZVAL_FALSE(EX_VAR(opline->result.var));
15507
0
    }
15508
876
  } else if (new_op_array->last == 1
15509
876
      && new_op_array->opcodes[0].opcode == ZEND_RETURN
15510
876
      && new_op_array->opcodes[0].op1_type == IS_CONST
15511
876
      && EXPECTED(zend_execute_ex == execute_ex)) {
15512
378
    if (RETURN_VALUE_USED(opline)) {
15513
0
      const zend_op *op = new_op_array->opcodes;
15514
15515
0
      ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
15516
0
    }
15517
378
    zend_destroy_static_vars(new_op_array);
15518
378
    destroy_op_array(new_op_array);
15519
378
    efree_size(new_op_array, sizeof(zend_op_array));
15520
498
  } else {
15521
498
    zval *return_value = NULL;
15522
498
    zend_execute_data *call;
15523
498
    if (RETURN_VALUE_USED(opline)) {
15524
102
      return_value = EX_VAR(opline->result.var);
15525
102
    }
15526
15527
498
    new_op_array->scope = EX(func)->op_array.scope;
15528
15529
498
    call = zend_vm_stack_push_call_frame(
15530
498
      (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
15531
498
      (zend_function*)new_op_array, 0,
15532
498
      Z_PTR(EX(This)));
15533
15534
498
    if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
15535
230
      call->symbol_table = EX(symbol_table);
15536
268
    } else {
15537
268
      call->symbol_table = zend_rebuild_symbol_table();
15538
268
    }
15539
15540
498
    call->prev_execute_data = execute_data;
15541
498
    i_init_code_execute_data(call, new_op_array, return_value);
15542
15543
498
    if (EXPECTED(zend_execute_ex == execute_ex)) {
15544
69
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15545
69
      ZEND_VM_ENTER();
15546
429
    } else {
15547
429
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
15548
429
      zend_execute_ex(call);
15549
429
      zend_vm_stack_free_call_frame(call);
15550
429
    }
15551
15552
429
    zend_destroy_static_vars(new_op_array);
15553
429
    destroy_op_array(new_op_array);
15554
429
    efree_size(new_op_array, sizeof(zend_op_array));
15555
429
    if (UNEXPECTED(EG(exception) != NULL)) {
15556
73
      zend_rethrow_exception(execute_data);
15557
73
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15558
73
      UNDEF_RESULT();
15559
73
      HANDLE_EXCEPTION();
15560
73
    }
15561
429
  }
15562
736
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15563
736
  ZEND_VM_NEXT_OPCODE();
15564
736
}
15565
15566
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15567
981
{
15568
981
  USE_OPLINE
15569
981
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
15570
981
  zval *val;
15571
15572
981
  SAVE_OPLINE();
15573
981
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15574
15575
981
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
15576
10
    zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
15577
10
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15578
10
    UNDEF_RESULT();
15579
10
    HANDLE_EXCEPTION();
15580
10
  }
15581
15582
971
yield_from_try_again:
15583
971
  if (Z_TYPE_P(val) == IS_ARRAY) {
15584
33
    ZVAL_COPY_VALUE(&generator->values, val);
15585
33
    if (Z_OPT_REFCOUNTED_P(val)) {
15586
28
      Z_ADDREF_P(val);
15587
28
    }
15588
33
    Z_FE_POS(generator->values) = 0;
15589
33
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15590
938
  } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
15591
928
    zend_class_entry *ce = Z_OBJCE_P(val);
15592
928
    if (ce == zend_ce_generator) {
15593
856
      zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
15594
15595
856
      Z_ADDREF_P(val);
15596
856
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15597
15598
856
      if (UNEXPECTED(new_gen->execute_data == NULL)) {
15599
0
        zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
15600
0
        zval_ptr_dtor(val);
15601
0
        UNDEF_RESULT();
15602
0
        HANDLE_EXCEPTION();
15603
856
      } else if (Z_ISUNDEF(new_gen->retval)) {
15604
856
        if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
15605
5
          zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
15606
5
          zval_ptr_dtor(val);
15607
5
          UNDEF_RESULT();
15608
5
          HANDLE_EXCEPTION();
15609
851
        } else {
15610
851
          zend_generator_yield_from(generator, new_gen);
15611
851
        }
15612
856
      } else {
15613
0
        if (RETURN_VALUE_USED(opline)) {
15614
0
          ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
15615
0
        }
15616
0
        ZEND_VM_NEXT_OPCODE();
15617
0
      }
15618
856
    } else {
15619
72
      zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
15620
72
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15621
15622
72
      if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
15623
3
        if (!EG(exception)) {
15624
0
          zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
15625
0
        }
15626
3
        UNDEF_RESULT();
15627
3
        HANDLE_EXCEPTION();
15628
3
      }
15629
15630
69
      iter->index = 0;
15631
69
      if (iter->funcs->rewind) {
15632
69
        iter->funcs->rewind(iter);
15633
69
        if (UNEXPECTED(EG(exception) != NULL)) {
15634
2
          OBJ_RELEASE(&iter->std);
15635
2
          UNDEF_RESULT();
15636
2
          HANDLE_EXCEPTION();
15637
2
        }
15638
69
      }
15639
15640
67
      ZVAL_OBJ(&generator->values, &iter->std);
15641
67
    }
15642
928
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
15643
0
    val = Z_REFVAL_P(val);
15644
0
    goto yield_from_try_again;
15645
10
  } else {
15646
10
    zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
15647
10
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15648
10
    UNDEF_RESULT();
15649
10
    HANDLE_EXCEPTION();
15650
10
  }
15651
15652
  /* This is the default return value
15653
   * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
15654
951
  if (RETURN_VALUE_USED(opline)) {
15655
951
    ZVAL_NULL(EX_VAR(opline->result.var));
15656
951
  }
15657
15658
  /* This generator has no send target (though the generator we delegate to might have one) */
15659
951
  generator->send_target = NULL;
15660
15661
  /* The GOTO VM uses a local opline variable. We need to set the opline
15662
   * variable in execute_data so we don't resume at an old position. */
15663
951
  SAVE_OPLINE();
15664
15665
951
  ZEND_VM_RETURN();
15666
971
}
15667
15668
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15669
56
{
15670
56
  USE_OPLINE
15671
56
  zval *value;
15672
15673
56
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15674
56
  if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15675
43
    ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15676
43
    if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15677
43
      zval_ptr_dtor_str(value);
15678
43
    }
15679
43
    ZEND_VM_NEXT_OPCODE();
15680
43
  } else {
15681
13
    bool strict;
15682
15683
13
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
15684
0
      value = Z_REFVAL_P(value);
15685
0
      if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15686
0
        ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15687
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15688
0
        ZEND_VM_NEXT_OPCODE();
15689
0
      }
15690
0
    }
15691
15692
13
    SAVE_OPLINE();
15693
13
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15694
0
      value = ZVAL_UNDEFINED_OP1();
15695
0
    }
15696
13
    strict = EX_USES_STRICT_TYPES();
15697
13
    do {
15698
13
      if (EXPECTED(!strict)) {
15699
13
        zend_string *str;
15700
13
        zval tmp;
15701
15702
13
        if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
15703
13
          zend_error(E_DEPRECATED,
15704
13
            "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
15705
13
          ZVAL_LONG(EX_VAR(opline->result.var), 0);
15706
13
          if (UNEXPECTED(EG(exception))) {
15707
0
            HANDLE_EXCEPTION();
15708
0
          }
15709
13
          break;
15710
13
        }
15711
15712
0
        ZVAL_COPY(&tmp, value);
15713
0
        if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
15714
0
          ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
15715
0
          zval_ptr_dtor(&tmp);
15716
0
          break;
15717
0
        }
15718
0
        zval_ptr_dtor(&tmp);
15719
0
      }
15720
0
      if (!EG(exception)) {
15721
0
        zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
15722
0
      }
15723
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
15724
0
    } while (0);
15725
13
  }
15726
13
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15727
13
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15728
13
}
15729
15730
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15731
2.26k
{
15732
2.26k
  USE_OPLINE
15733
2.26k
  zval *value;
15734
2.26k
  int result = 0;
15735
15736
2.26k
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15737
2.26k
  if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15738
653
type_check_resource:
15739
653
    if (opline->extended_value != MAY_BE_RESOURCE
15740
653
     || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
15741
653
      result = 1;
15742
653
    }
15743
1.61k
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
15744
0
    value = Z_REFVAL_P(value);
15745
0
    if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15746
0
      goto type_check_resource;
15747
0
    }
15748
1.61k
  } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15749
0
    result = ((1 << IS_NULL) & opline->extended_value) != 0;
15750
0
    SAVE_OPLINE();
15751
0
    ZVAL_UNDEFINED_OP1();
15752
0
    if (UNEXPECTED(EG(exception))) {
15753
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
15754
0
      HANDLE_EXCEPTION();
15755
0
    }
15756
0
  }
15757
2.26k
  if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15758
2.26k
    SAVE_OPLINE();
15759
2.26k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15760
2.26k
    ZEND_VM_SMART_BRANCH(result, 1);
15761
2.26k
  } else {
15762
0
    ZEND_VM_SMART_BRANCH(result, 0);
15763
0
  }
15764
2.26k
}
15765
15766
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15767
32
{
15768
32
  uint32_t fetch_type;
15769
32
  zend_class_entry *called_scope, *scope;
15770
32
  USE_OPLINE
15771
15772
32
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
15773
32
    SAVE_OPLINE();
15774
32
    zval *op = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15775
32
    if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
15776
3
      ZVAL_DEREF(op);
15777
3
      if (Z_TYPE_P(op) != IS_OBJECT) {
15778
3
        zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
15779
3
        ZVAL_UNDEF(EX_VAR(opline->result.var));
15780
3
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15781
3
        HANDLE_EXCEPTION();
15782
3
      }
15783
3
    }
15784
15785
29
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
15786
29
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15787
29
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15788
29
  }
15789
15790
0
  fetch_type = opline->op1.num;
15791
0
  scope = EX(func)->op_array.scope;
15792
0
  if (UNEXPECTED(scope == NULL)) {
15793
0
    SAVE_OPLINE();
15794
0
    zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
15795
0
      fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
15796
0
      fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
15797
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
15798
0
    HANDLE_EXCEPTION();
15799
0
  }
15800
15801
0
  switch (fetch_type) {
15802
0
    case ZEND_FETCH_CLASS_SELF:
15803
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
15804
0
      break;
15805
0
    case ZEND_FETCH_CLASS_PARENT:
15806
0
      if (UNEXPECTED(scope->parent == NULL)) {
15807
0
        SAVE_OPLINE();
15808
0
        zend_throw_error(NULL,
15809
0
          "Cannot use \"parent\" when current class scope has no parent");
15810
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
15811
0
        HANDLE_EXCEPTION();
15812
0
      }
15813
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
15814
0
      break;
15815
0
    case ZEND_FETCH_CLASS_STATIC:
15816
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
15817
0
        called_scope = Z_OBJCE(EX(This));
15818
0
      } else {
15819
0
        called_scope = Z_CE(EX(This));
15820
0
      }
15821
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
15822
0
      break;
15823
0
    EMPTY_SWITCH_DEFAULT_CASE()
15824
0
  }
15825
0
  ZEND_VM_NEXT_OPCODE();
15826
0
}
15827
15828
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15829
122
{
15830
122
  USE_OPLINE
15831
122
  zval *op1, *op2;
15832
15833
122
  SAVE_OPLINE();
15834
122
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15835
122
  op2 = RT_CONSTANT(opline, opline->op2);
15836
122
  div_function(EX_VAR(opline->result.var), op1, op2);
15837
122
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15838
15839
122
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15840
122
}
15841
15842
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15843
0
{
15844
0
  USE_OPLINE
15845
0
  zval *op1, *op2;
15846
15847
0
  SAVE_OPLINE();
15848
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15849
0
  op2 = RT_CONSTANT(opline, opline->op2);
15850
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
15851
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15852
15853
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15854
0
}
15855
15856
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15857
19.6k
{
15858
19.6k
  USE_OPLINE
15859
19.6k
  zval *op1, *op2;
15860
15861
19.6k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15862
19.6k
  op2 = RT_CONSTANT(opline, opline->op2);
15863
15864
19.6k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
15865
19.6k
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
15866
16.9k
    zend_string *op1_str = Z_STR_P(op1);
15867
16.9k
    zend_string *op2_str = Z_STR_P(op2);
15868
16.9k
    zend_string *str;
15869
16.9k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
15870
15871
16.9k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
15872
213
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
15873
213
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
15874
213
      } else {
15875
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
15876
0
      }
15877
213
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15878
213
        zend_string_release_ex(op1_str, 0);
15879
213
      }
15880
16.7k
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
15881
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
15882
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
15883
0
      } else {
15884
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
15885
0
      }
15886
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15887
0
        zend_string_release_ex(op2_str, 0);
15888
0
      }
15889
16.7k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
15890
16.7k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
15891
5.97k
      size_t len = ZSTR_LEN(op1_str);
15892
15893
5.97k
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
15894
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
15895
0
      }
15896
5.97k
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
15897
5.97k
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15898
5.97k
      GC_ADD_FLAGS(str, flags);
15899
5.97k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15900
5.97k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15901
0
        zend_string_release_ex(op2_str, 0);
15902
0
      }
15903
10.7k
    } else {
15904
10.7k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
15905
10.7k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
15906
10.7k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15907
10.7k
      GC_ADD_FLAGS(str, flags);
15908
10.7k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15909
10.7k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15910
10.7k
        zend_string_release_ex(op1_str, 0);
15911
10.7k
      }
15912
10.7k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15913
0
        zend_string_release_ex(op2_str, 0);
15914
0
      }
15915
10.7k
    }
15916
16.9k
    ZEND_VM_NEXT_OPCODE();
15917
16.9k
  } else {
15918
2.69k
    SAVE_OPLINE();
15919
15920
2.69k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
15921
0
      op1 = ZVAL_UNDEFINED_OP1();
15922
0
    }
15923
2.69k
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
15924
0
      op2 = ZVAL_UNDEFINED_OP2();
15925
0
    }
15926
2.69k
    concat_function(EX_VAR(opline->result.var), op1, op2);
15927
2.69k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15928
15929
2.69k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15930
2.69k
  }
15931
19.6k
}
15932
15933
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15934
238
{
15935
238
  USE_OPLINE
15936
238
  zval *op1, *op2;
15937
238
  double d1, d2;
15938
15939
238
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15940
238
  op2 = RT_CONSTANT(opline, opline->op2);
15941
238
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15942
    /* pass */
15943
238
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15944
31
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15945
31
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15946
81
is_equal_true:
15947
81
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
15948
81
      } else {
15949
132
is_equal_false:
15950
132
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
15951
132
      }
15952
31
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15953
0
      d1 = (double)Z_LVAL_P(op1);
15954
0
      d2 = Z_DVAL_P(op2);
15955
0
      goto is_equal_double;
15956
0
    }
15957
207
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15958
13
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15959
0
      d1 = Z_DVAL_P(op1);
15960
0
      d2 = Z_DVAL_P(op2);
15961
0
is_equal_double:
15962
0
      if (d1 == d2) {
15963
0
        goto is_equal_true;
15964
0
      } else {
15965
0
        goto is_equal_false;
15966
0
      }
15967
13
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15968
0
      d1 = Z_DVAL_P(op1);
15969
0
      d2 = (double)Z_LVAL_P(op2);
15970
0
      goto is_equal_double;
15971
0
    }
15972
194
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15973
182
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15974
182
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15975
182
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15976
182
        zval_ptr_dtor_str(op1);
15977
182
      }
15978
182
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15979
0
        zval_ptr_dtor_str(op2);
15980
0
      }
15981
182
      if (result) {
15982
50
        goto is_equal_true;
15983
132
      } else {
15984
132
        goto is_equal_false;
15985
132
      }
15986
182
    }
15987
182
  }
15988
238
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
15989
238
}
15990
15991
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15992
23.5k
{
15993
23.5k
  USE_OPLINE
15994
23.5k
  zval *op1, *op2;
15995
23.5k
  double d1, d2;
15996
15997
23.5k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15998
23.5k
  op2 = RT_CONSTANT(opline, opline->op2);
15999
23.5k
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16000
    /* pass */
16001
23.5k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16002
23.3k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16003
23.3k
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16004
23.2k
is_equal_true:
16005
23.2k
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
16006
23.2k
      } else {
16007
137
is_equal_false:
16008
137
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
16009
137
      }
16010
23.3k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16011
4
      d1 = (double)Z_LVAL_P(op1);
16012
4
      d2 = Z_DVAL_P(op2);
16013
4
      goto is_equal_double;
16014
4
    }
16015
23.3k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16016
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16017
0
      d1 = Z_DVAL_P(op1);
16018
0
      d2 = Z_DVAL_P(op2);
16019
4
is_equal_double:
16020
4
      if (d1 == d2) {
16021
0
        goto is_equal_true;
16022
4
      } else {
16023
4
        goto is_equal_false;
16024
4
      }
16025
4
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16026
0
      d1 = Z_DVAL_P(op1);
16027
0
      d2 = (double)Z_LVAL_P(op2);
16028
0
      goto is_equal_double;
16029
0
    }
16030
159
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16031
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16032
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16033
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16034
0
        zval_ptr_dtor_str(op1);
16035
0
      }
16036
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16037
0
        zval_ptr_dtor_str(op2);
16038
0
      }
16039
0
      if (result) {
16040
0
        goto is_equal_true;
16041
0
      } else {
16042
0
        goto is_equal_false;
16043
0
      }
16044
0
    }
16045
0
  }
16046
23.5k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16047
23.5k
}
16048
16049
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16050
363
{
16051
363
  USE_OPLINE
16052
363
  zval *op1, *op2;
16053
363
  double d1, d2;
16054
16055
363
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16056
363
  op2 = RT_CONSTANT(opline, opline->op2);
16057
363
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16058
    /* pass */
16059
363
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16060
363
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16061
67
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16062
43
is_equal_true:
16063
43
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
16064
43
      } else {
16065
320
is_equal_false:
16066
320
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
16067
320
      }
16068
296
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16069
296
      d1 = (double)Z_LVAL_P(op1);
16070
296
      d2 = Z_DVAL_P(op2);
16071
296
      goto is_equal_double;
16072
296
    }
16073
363
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16074
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16075
0
      d1 = Z_DVAL_P(op1);
16076
0
      d2 = Z_DVAL_P(op2);
16077
296
is_equal_double:
16078
296
      if (d1 == d2) {
16079
0
        goto is_equal_true;
16080
296
      } else {
16081
296
        goto is_equal_false;
16082
296
      }
16083
296
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16084
0
      d1 = Z_DVAL_P(op1);
16085
0
      d2 = (double)Z_LVAL_P(op2);
16086
0
      goto is_equal_double;
16087
0
    }
16088
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16089
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16090
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16091
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16092
0
        zval_ptr_dtor_str(op1);
16093
0
      }
16094
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16095
0
        zval_ptr_dtor_str(op2);
16096
0
      }
16097
0
      if (result) {
16098
0
        goto is_equal_true;
16099
0
      } else {
16100
0
        goto is_equal_false;
16101
0
      }
16102
0
    }
16103
0
  }
16104
363
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16105
363
}
16106
16107
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16108
1.23k
{
16109
1.23k
  USE_OPLINE
16110
1.23k
  zval *op1, *op2;
16111
1.23k
  double d1, d2;
16112
16113
1.23k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16114
1.23k
  op2 = RT_CONSTANT(opline, opline->op2);
16115
1.23k
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16116
    /* pass */
16117
1.23k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16118
323
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16119
278
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16120
210
is_not_equal_true:
16121
210
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
16122
210
      } else {
16123
93
is_not_equal_false:
16124
93
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
16125
93
      }
16126
278
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16127
0
      d1 = (double)Z_LVAL_P(op1);
16128
0
      d2 = Z_DVAL_P(op2);
16129
0
      goto is_not_equal_double;
16130
0
    }
16131
910
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16132
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16133
0
      d1 = Z_DVAL_P(op1);
16134
0
      d2 = Z_DVAL_P(op2);
16135
0
is_not_equal_double:
16136
0
      if (d1 != d2) {
16137
0
        goto is_not_equal_true;
16138
0
      } else {
16139
0
        goto is_not_equal_false;
16140
0
      }
16141
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16142
0
      d1 = Z_DVAL_P(op1);
16143
0
      d2 = (double)Z_LVAL_P(op2);
16144
0
      goto is_not_equal_double;
16145
0
    }
16146
910
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16147
300
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16148
25
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16149
25
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16150
25
        zval_ptr_dtor_str(op1);
16151
25
      }
16152
25
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16153
0
        zval_ptr_dtor_str(op2);
16154
0
      }
16155
25
      if (!result) {
16156
25
        goto is_not_equal_true;
16157
25
      } else {
16158
0
        goto is_not_equal_false;
16159
0
      }
16160
25
    }
16161
300
  }
16162
1.23k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16163
1.23k
}
16164
16165
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16166
12
{
16167
12
  USE_OPLINE
16168
12
  zval *op1, *op2;
16169
12
  double d1, d2;
16170
16171
12
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16172
12
  op2 = RT_CONSTANT(opline, opline->op2);
16173
12
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16174
    /* pass */
16175
12
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16176
12
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16177
12
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16178
7
is_not_equal_true:
16179
7
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
16180
7
      } else {
16181
5
is_not_equal_false:
16182
5
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
16183
5
      }
16184
12
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16185
0
      d1 = (double)Z_LVAL_P(op1);
16186
0
      d2 = Z_DVAL_P(op2);
16187
0
      goto is_not_equal_double;
16188
0
    }
16189
12
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16190
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16191
0
      d1 = Z_DVAL_P(op1);
16192
0
      d2 = Z_DVAL_P(op2);
16193
0
is_not_equal_double:
16194
0
      if (d1 != d2) {
16195
0
        goto is_not_equal_true;
16196
0
      } else {
16197
0
        goto is_not_equal_false;
16198
0
      }
16199
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16200
0
      d1 = Z_DVAL_P(op1);
16201
0
      d2 = (double)Z_LVAL_P(op2);
16202
0
      goto is_not_equal_double;
16203
0
    }
16204
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16205
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16206
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16207
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16208
0
        zval_ptr_dtor_str(op1);
16209
0
      }
16210
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16211
0
        zval_ptr_dtor_str(op2);
16212
0
      }
16213
0
      if (!result) {
16214
0
        goto is_not_equal_true;
16215
0
      } else {
16216
0
        goto is_not_equal_false;
16217
0
      }
16218
0
    }
16219
0
  }
16220
12
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16221
12
}
16222
16223
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16224
0
{
16225
0
  USE_OPLINE
16226
0
  zval *op1, *op2;
16227
0
  double d1, d2;
16228
16229
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16230
0
  op2 = RT_CONSTANT(opline, opline->op2);
16231
0
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16232
    /* pass */
16233
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16234
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16235
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16236
0
is_not_equal_true:
16237
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
16238
0
      } else {
16239
0
is_not_equal_false:
16240
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
16241
0
      }
16242
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16243
0
      d1 = (double)Z_LVAL_P(op1);
16244
0
      d2 = Z_DVAL_P(op2);
16245
0
      goto is_not_equal_double;
16246
0
    }
16247
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16248
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16249
0
      d1 = Z_DVAL_P(op1);
16250
0
      d2 = Z_DVAL_P(op2);
16251
0
is_not_equal_double:
16252
0
      if (d1 != d2) {
16253
0
        goto is_not_equal_true;
16254
0
      } else {
16255
0
        goto is_not_equal_false;
16256
0
      }
16257
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16258
0
      d1 = Z_DVAL_P(op1);
16259
0
      d2 = (double)Z_LVAL_P(op2);
16260
0
      goto is_not_equal_double;
16261
0
    }
16262
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16263
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16264
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16265
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16266
0
        zval_ptr_dtor_str(op1);
16267
0
      }
16268
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16269
0
        zval_ptr_dtor_str(op2);
16270
0
      }
16271
0
      if (!result) {
16272
0
        goto is_not_equal_true;
16273
0
      } else {
16274
0
        goto is_not_equal_false;
16275
0
      }
16276
0
    }
16277
0
  }
16278
0
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16279
0
}
16280
16281
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16282
0
{
16283
0
  USE_OPLINE
16284
0
  zval *op1, *op2;
16285
16286
0
  SAVE_OPLINE();
16287
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16288
0
  op2 = RT_CONSTANT(opline, opline->op2);
16289
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
16290
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16291
16292
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16293
0
}
16294
16295
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16296
11.1k
{
16297
11.1k
  USE_OPLINE
16298
11.1k
  zval *op1, *op2;
16299
16300
11.1k
  SAVE_OPLINE();
16301
11.1k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16302
11.1k
  op2 = RT_CONSTANT(opline, opline->op2);
16303
11.1k
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
16304
11.1k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16305
16306
11.1k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16307
11.1k
}
16308
16309
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16310
2.61k
{
16311
2.61k
  USE_OPLINE
16312
2.61k
  zval *container, *dim, *value;
16313
16314
2.61k
  SAVE_OPLINE();
16315
2.61k
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16316
2.61k
  dim = RT_CONSTANT(opline, opline->op2);
16317
2.61k
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16318
2.61k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16319
1.21k
fetch_dim_r_array:
16320
1.21k
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
16321
1.21k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
16322
1.39k
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
16323
0
      container = Z_REFVAL_P(container);
16324
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16325
0
        goto fetch_dim_r_array;
16326
0
      } else {
16327
0
        goto fetch_dim_r_slow;
16328
0
      }
16329
1.39k
    } else {
16330
1.39k
fetch_dim_r_slow:
16331
1.39k
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
16332
6
        dim++;
16333
6
      }
16334
1.39k
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
16335
1.39k
    }
16336
2.61k
  } else {
16337
0
    zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16338
0
  }
16339
16340
2.61k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16341
2.61k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16342
2.61k
}
16343
16344
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16345
777
{
16346
777
  USE_OPLINE
16347
777
  zval *container;
16348
16349
777
  SAVE_OPLINE();
16350
777
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16351
777
  zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16352
16353
777
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16354
777
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16355
777
}
16356
16357
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16358
4.59k
{
16359
4.59k
  USE_OPLINE
16360
4.59k
  zval *container;
16361
4.59k
  void **cache_slot = NULL;
16362
16363
4.59k
  SAVE_OPLINE();
16364
4.59k
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16365
16366
4.59k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16367
4.59k
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16368
3.89k
    do {
16369
3.89k
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16370
0
        container = Z_REFVAL_P(container);
16371
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
16372
0
          break;
16373
0
        }
16374
0
      }
16375
3.89k
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
16376
0
        ZVAL_UNDEFINED_OP1();
16377
0
      }
16378
3.89k
      zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
16379
3.89k
      ZVAL_NULL(EX_VAR(opline->result.var));
16380
3.89k
      goto fetch_obj_r_finish;
16381
3.89k
    } while (0);
16382
3.89k
  }
16383
16384
  /* here we are sure we are dealing with an object */
16385
702
  do {
16386
702
    zend_object *zobj = Z_OBJ_P(container);
16387
702
    zend_string *name, *tmp_name;
16388
702
    zval *retval;
16389
16390
702
    if (IS_CONST == IS_CONST) {
16391
702
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
16392
16393
702
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
16394
57
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
16395
16396
57
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
16397
52
fetch_obj_r_simple:
16398
52
          retval = OBJ_PROP(zobj, prop_offset);
16399
52
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
16400
37
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16401
37
              goto fetch_obj_r_copy;
16402
37
            } else {
16403
0
fetch_obj_r_fast_copy:
16404
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16405
0
              ZEND_VM_NEXT_OPCODE();
16406
0
            }
16407
37
          }
16408
52
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
16409
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
16410
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
16411
0
            prop_offset = prop_info->offset;
16412
0
            goto fetch_obj_r_simple;
16413
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
16414
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
16415
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
16416
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
16417
16418
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16419
0
            if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
16420
0
              GC_ADDREF(zobj);
16421
0
            }
16422
0
            if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
16423
0
              call_info |= ZEND_CALL_RELEASE_THIS;
16424
0
            }
16425
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
16426
0
            call->prev_execute_data = execute_data;
16427
0
            call->call = NULL;
16428
0
            call->return_value = EX_VAR(opline->result.var);
16429
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
16430
16431
0
            execute_data = call;
16432
0
            EG(current_execute_data) = execute_data;
16433
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
16434
16435
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
16436
            opline = hook->op_array.opcodes;
16437
#else
16438
0
            EX(opline) = hook->op_array.opcodes;
16439
0
#endif
16440
0
            LOAD_OPLINE_EX();
16441
16442
16443
0
            ZEND_VM_ENTER_EX();
16444
0
          }
16445
          /* Fall through to read_property for hooks. */
16446
5
        } else if (EXPECTED(zobj->properties != NULL)) {
16447
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
16448
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16449
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
16450
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
16451
16452
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
16453
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
16454
16455
0
              if (EXPECTED(p->key == name) ||
16456
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
16457
0
                   EXPECTED(p->key != NULL) &&
16458
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
16459
0
                retval = &p->val;
16460
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16461
0
                  goto fetch_obj_r_copy;
16462
0
                } else {
16463
0
                  goto fetch_obj_r_fast_copy;
16464
0
                }
16465
0
              }
16466
0
            }
16467
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
16468
0
          }
16469
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
16470
0
          if (EXPECTED(retval)) {
16471
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
16472
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
16473
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16474
0
              goto fetch_obj_r_copy;
16475
0
            } else {
16476
0
              goto fetch_obj_r_fast_copy;
16477
0
            }
16478
0
          }
16479
0
        }
16480
57
      }
16481
665
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16482
665
    } else {
16483
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16484
0
      if (UNEXPECTED(!name)) {
16485
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
16486
0
        break;
16487
0
      }
16488
0
    }
16489
16490
665
#if ZEND_DEBUG
16491
    /* For non-standard object handlers, verify a declared property type in debug builds.
16492
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
16493
665
    zend_property_info *prop_info = NULL;
16494
665
    if (zobj->handlers->read_property != zend_std_read_property) {
16495
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
16496
0
    }
16497
665
#endif
16498
665
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
16499
665
#if ZEND_DEBUG
16500
665
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
16501
665
        && ZEND_TYPE_IS_SET(prop_info->type)) {
16502
0
      ZVAL_OPT_DEREF(retval);
16503
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
16504
0
    }
16505
665
#endif
16506
16507
665
    if (IS_CONST != IS_CONST) {
16508
0
      zend_tmp_string_release(tmp_name);
16509
0
    }
16510
16511
665
    if (retval != EX_VAR(opline->result.var)) {
16512
629
fetch_obj_r_copy:
16513
629
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16514
629
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16515
0
      zend_unwrap_reference(retval);
16516
0
    }
16517
702
  } while (0);
16518
16519
4.59k
fetch_obj_r_finish:
16520
16521
4.59k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16522
4.59k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16523
4.59k
}
16524
16525
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16526
147
{
16527
147
  USE_OPLINE
16528
147
  zval *container;
16529
147
  void **cache_slot = NULL;
16530
16531
147
  SAVE_OPLINE();
16532
147
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16533
16534
147
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16535
147
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16536
93
    do {
16537
93
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16538
0
        container = Z_REFVAL_P(container);
16539
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
16540
0
          break;
16541
0
        }
16542
0
      }
16543
93
      if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
16544
0
        ZVAL_UNDEFINED_OP2();
16545
0
      }
16546
93
      ZVAL_NULL(EX_VAR(opline->result.var));
16547
93
      goto fetch_obj_is_finish;
16548
93
    } while (0);
16549
93
  }
16550
16551
  /* here we are sure we are dealing with an object */
16552
54
  do {
16553
54
    zend_object *zobj = Z_OBJ_P(container);
16554
54
    zend_string *name, *tmp_name;
16555
54
    zval *retval;
16556
16557
54
    if (IS_CONST == IS_CONST) {
16558
54
      cache_slot = CACHE_ADDR(opline->extended_value);
16559
16560
54
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
16561
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
16562
16563
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
16564
0
fetch_obj_is_simple:
16565
0
          retval = OBJ_PROP(zobj, prop_offset);
16566
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
16567
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16568
0
              goto fetch_obj_is_copy;
16569
0
            } else {
16570
0
fetch_obj_is_fast_copy:
16571
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16572
0
              ZEND_VM_NEXT_OPCODE();
16573
0
            }
16574
0
          }
16575
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
16576
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
16577
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
16578
0
            prop_offset = prop_info->offset;
16579
0
            goto fetch_obj_is_simple;
16580
0
          }
16581
          /* Fall through to read_property for hooks. */
16582
0
        } else if (EXPECTED(zobj->properties != NULL)) {
16583
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
16584
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16585
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
16586
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
16587
16588
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
16589
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
16590
16591
0
              if (EXPECTED(p->key == name) ||
16592
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
16593
0
                   EXPECTED(p->key != NULL) &&
16594
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
16595
0
                retval = &p->val;
16596
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16597
0
                  goto fetch_obj_is_copy;
16598
0
                } else {
16599
0
                  goto fetch_obj_is_fast_copy;
16600
0
                }
16601
0
              }
16602
0
            }
16603
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
16604
0
          }
16605
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
16606
0
          if (EXPECTED(retval)) {
16607
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
16608
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
16609
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16610
0
              goto fetch_obj_is_copy;
16611
0
            } else {
16612
0
              goto fetch_obj_is_fast_copy;
16613
0
            }
16614
0
          }
16615
0
        }
16616
0
      }
16617
54
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16618
54
    } else {
16619
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16620
0
      if (UNEXPECTED(!name)) {
16621
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
16622
0
        break;
16623
0
      }
16624
0
    }
16625
16626
54
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
16627
16628
54
    if (IS_CONST != IS_CONST) {
16629
0
      zend_tmp_string_release(tmp_name);
16630
0
    }
16631
16632
54
    if (retval != EX_VAR(opline->result.var)) {
16633
33
fetch_obj_is_copy:
16634
33
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16635
33
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16636
21
      zend_unwrap_reference(retval);
16637
21
    }
16638
54
  } while (0);
16639
16640
147
fetch_obj_is_finish:
16641
16642
147
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16643
147
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16644
147
}
16645
16646
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16647
208k
{
16648
208k
  USE_OPLINE
16649
208k
  zval *op1, *op2;
16650
208k
  zend_string *op1_str, *op2_str, *str;
16651
16652
16653
208k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16654
208k
  op2 = RT_CONSTANT(opline, opline->op2);
16655
208k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
16656
208k
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
16657
208k
    zend_string *op1_str = Z_STR_P(op1);
16658
208k
    zend_string *op2_str = Z_STR_P(op2);
16659
208k
    zend_string *str;
16660
208k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
16661
16662
208k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16663
8
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
16664
8
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
16665
8
      } else {
16666
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16667
0
      }
16668
8
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16669
8
        zend_string_release_ex(op1_str, 0);
16670
8
      }
16671
208k
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16672
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16673
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
16674
0
      } else {
16675
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16676
0
      }
16677
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16678
0
        zend_string_release_ex(op2_str, 0);
16679
0
      }
16680
208k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
16681
208k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
16682
207k
      size_t len = ZSTR_LEN(op1_str);
16683
16684
207k
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
16685
207k
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16686
207k
      GC_ADD_FLAGS(str, flags);
16687
207k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16688
207k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16689
0
        zend_string_release_ex(op2_str, 0);
16690
0
      }
16691
207k
    } else {
16692
602
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16693
602
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16694
602
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16695
602
      GC_ADD_FLAGS(str, flags);
16696
602
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16697
602
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16698
602
        zend_string_release_ex(op1_str, 0);
16699
602
      }
16700
602
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16701
0
        zend_string_release_ex(op2_str, 0);
16702
0
      }
16703
602
    }
16704
208k
    ZEND_VM_NEXT_OPCODE();
16705
208k
  }
16706
16707
208k
  SAVE_OPLINE();
16708
266
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16709
0
    op1_str = Z_STR_P(op1);
16710
266
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16711
0
    op1_str = zend_string_copy(Z_STR_P(op1));
16712
266
  } else {
16713
266
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
16714
0
      ZVAL_UNDEFINED_OP1();
16715
0
    }
16716
266
    op1_str = zval_get_string_func(op1);
16717
266
  }
16718
266
  if (IS_CONST == IS_CONST) {
16719
266
    op2_str = Z_STR_P(op2);
16720
266
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16721
0
    op2_str = zend_string_copy(Z_STR_P(op2));
16722
0
  } else {
16723
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
16724
0
      ZVAL_UNDEFINED_OP2();
16725
0
    }
16726
0
    op2_str = zval_get_string_func(op2);
16727
0
  }
16728
266
  do {
16729
266
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16730
266
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16731
94
        if (IS_CONST == IS_CONST) {
16732
94
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
16733
0
            GC_ADDREF(op2_str);
16734
0
          }
16735
94
        }
16736
94
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16737
94
        zend_string_release_ex(op1_str, 0);
16738
94
        break;
16739
94
      }
16740
266
    }
16741
172
    if (IS_CONST != IS_CONST) {
16742
0
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16743
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16744
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
16745
0
            GC_ADDREF(op1_str);
16746
0
          }
16747
0
        }
16748
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16749
0
        zend_string_release_ex(op2_str, 0);
16750
0
        break;
16751
0
      }
16752
0
    }
16753
172
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16754
172
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16755
172
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16756
16757
172
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
16758
172
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16759
172
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16760
172
      zend_string_release_ex(op1_str, 0);
16761
172
    }
16762
172
    if (IS_CONST != IS_CONST) {
16763
0
      zend_string_release_ex(op2_str, 0);
16764
0
    }
16765
172
  } while (0);
16766
266
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16767
16768
266
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16769
266
}
16770
16771
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16772
4.12k
{
16773
4.12k
  USE_OPLINE
16774
4.12k
  zval *function_name;
16775
4.12k
  zval *object;
16776
4.12k
  zend_function *fbc;
16777
4.12k
  zend_class_entry *called_scope;
16778
4.12k
  zend_object *obj;
16779
4.12k
  zend_execute_data *call;
16780
4.12k
  uint32_t call_info;
16781
16782
4.12k
  SAVE_OPLINE();
16783
16784
4.12k
  object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16785
16786
4.12k
  if (IS_CONST != IS_CONST) {
16787
0
    function_name = RT_CONSTANT(opline, opline->op2);
16788
0
  }
16789
16790
4.12k
  if (IS_CONST != IS_CONST &&
16791
4.12k
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
16792
0
    do {
16793
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
16794
0
        function_name = Z_REFVAL_P(function_name);
16795
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
16796
0
          break;
16797
0
        }
16798
0
      } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
16799
0
        ZVAL_UNDEFINED_OP2();
16800
0
        if (UNEXPECTED(EG(exception) != NULL)) {
16801
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16802
0
          HANDLE_EXCEPTION();
16803
0
        }
16804
0
      }
16805
0
      zend_throw_error(NULL, "Method name must be a string");
16806
16807
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16808
0
      HANDLE_EXCEPTION();
16809
0
    } while (0);
16810
0
  }
16811
16812
4.12k
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
16813
0
    obj = Z_OBJ_P(object);
16814
4.12k
  } else {
16815
4.12k
    do {
16816
4.12k
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16817
4.00k
        obj = Z_OBJ_P(object);
16818
4.00k
      } else {
16819
124
        if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
16820
79
          zend_reference *ref = Z_REF_P(object);
16821
16822
79
          object = &ref->val;
16823
79
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16824
79
            obj = Z_OBJ_P(object);
16825
79
            if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
16826
79
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
16827
2
                efree_size(ref, sizeof(zend_reference));
16828
77
              } else {
16829
77
                Z_ADDREF_P(object);
16830
77
              }
16831
79
            }
16832
79
            break;
16833
79
          }
16834
79
        }
16835
45
        if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
16836
0
          object = ZVAL_UNDEFINED_OP1();
16837
0
          if (UNEXPECTED(EG(exception) != NULL)) {
16838
0
            if (IS_CONST != IS_CONST) {
16839
16840
0
            }
16841
0
            HANDLE_EXCEPTION();
16842
0
          }
16843
0
        }
16844
45
        if (IS_CONST == IS_CONST) {
16845
45
          function_name = RT_CONSTANT(opline, opline->op2);
16846
45
        }
16847
45
        zend_invalid_method_call(object, function_name);
16848
16849
45
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16850
45
        HANDLE_EXCEPTION();
16851
45
      }
16852
4.12k
    } while (0);
16853
4.12k
  }
16854
16855
4.08k
  called_scope = obj->ce;
16856
16857
4.08k
  if (IS_CONST == IS_CONST &&
16858
4.08k
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
16859
589
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
16860
3.49k
  } else {
16861
3.49k
    zend_object *orig_obj = obj;
16862
16863
3.49k
    if (IS_CONST == IS_CONST) {
16864
3.49k
      function_name = RT_CONSTANT(opline, opline->op2);
16865
3.49k
    }
16866
16867
    /* First, locate the function. */
16868
3.49k
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
16869
3.49k
    if (UNEXPECTED(fbc == NULL)) {
16870
44
      if (EXPECTED(!EG(exception))) {
16871
44
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
16872
44
      }
16873
16874
44
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
16875
37
        zend_objects_store_del(orig_obj);
16876
37
      }
16877
44
      HANDLE_EXCEPTION();
16878
44
    }
16879
3.44k
    if (IS_CONST == IS_CONST &&
16880
3.44k
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
16881
3.44k
        EXPECTED(obj == orig_obj)) {
16882
3.39k
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
16883
3.39k
    }
16884
3.44k
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
16885
0
      GC_ADDREF(obj); /* For $this pointer */
16886
0
      if (GC_DELREF(orig_obj) == 0) {
16887
0
        zend_objects_store_del(orig_obj);
16888
0
      }
16889
0
    }
16890
3.44k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
16891
559
      init_func_run_time_cache(&fbc->op_array);
16892
559
    }
16893
3.44k
  }
16894
16895
4.03k
  if (IS_CONST != IS_CONST) {
16896
16897
0
  }
16898
16899
4.03k
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16900
4.03k
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
16901
10
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
16902
10
      zend_objects_store_del(obj);
16903
10
      if (UNEXPECTED(EG(exception))) {
16904
0
        HANDLE_EXCEPTION();
16905
0
      }
16906
10
    }
16907
    /* call static method */
16908
10
    obj = (zend_object*)called_scope;
16909
10
    call_info = ZEND_CALL_NESTED_FUNCTION;
16910
4.02k
  } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
16911
4.02k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
16912
0
      GC_ADDREF(obj); /* For $this pointer */
16913
0
    }
16914
    /* CV may be changed indirectly (e.g. when it's a reference) */
16915
4.02k
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
16916
4.02k
  }
16917
16918
4.03k
  call = zend_vm_stack_push_call_frame(call_info,
16919
4.03k
    fbc, opline->extended_value, obj);
16920
4.03k
  call->prev_execute_data = EX(call);
16921
4.03k
  EX(call) = call;
16922
16923
4.03k
  ZEND_VM_NEXT_OPCODE();
16924
4.03k
}
16925
16926
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16927
26
{
16928
26
  USE_OPLINE
16929
26
  zval *value, *arg;
16930
16931
26
  if (IS_CONST == IS_CONST) {
16932
26
    SAVE_OPLINE();
16933
26
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16934
26
    uint32_t arg_num;
16935
26
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
16936
26
    if (UNEXPECTED(!arg)) {
16937
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16938
0
      HANDLE_EXCEPTION();
16939
0
    }
16940
26
  } else {
16941
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
16942
0
  }
16943
16944
26
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16945
26
  ZVAL_COPY_VALUE(arg, value);
16946
26
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16947
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
16948
0
      Z_ADDREF_P(arg);
16949
0
    }
16950
0
  }
16951
26
  ZEND_VM_NEXT_OPCODE();
16952
26
}
16953
16954
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16955
549
{
16956
549
  USE_OPLINE
16957
549
  zval *op1, *op2;
16958
549
  double d1, d2;
16959
16960
549
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16961
549
  op2 = RT_CONSTANT(opline, opline->op2);
16962
549
  if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16963
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16964
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16965
31
case_true:
16966
31
        ZEND_VM_SMART_BRANCH_TRUE();
16967
31
      } else {
16968
456
case_false:
16969
456
        ZEND_VM_SMART_BRANCH_FALSE();
16970
456
      }
16971
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16972
0
      d1 = (double)Z_LVAL_P(op1);
16973
0
      d2 = Z_DVAL_P(op2);
16974
0
      goto case_double;
16975
0
    }
16976
549
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16977
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16978
0
      d1 = Z_DVAL_P(op1);
16979
0
      d2 = Z_DVAL_P(op2);
16980
0
case_double:
16981
0
      if (d1 == d2) {
16982
0
        goto case_true;
16983
0
      } else {
16984
0
        goto case_false;
16985
0
      }
16986
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16987
0
      d1 = Z_DVAL_P(op1);
16988
0
      d2 = (double)Z_LVAL_P(op2);
16989
0
      goto case_double;
16990
0
    }
16991
549
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16992
487
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16993
487
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16994
16995
487
      if (result) {
16996
31
        goto case_true;
16997
456
      } else {
16998
456
        goto case_false;
16999
456
      }
17000
487
    }
17001
487
  }
17002
549
  ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17003
549
}
17004
17005
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17006
309
{
17007
309
  USE_OPLINE
17008
309
  zval *container;
17009
309
  bool result;
17010
309
  zend_ulong hval;
17011
309
  zval *offset;
17012
17013
309
  SAVE_OPLINE();
17014
309
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17015
309
  offset = RT_CONSTANT(opline, opline->op2);
17016
17017
309
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17018
47
    HashTable *ht;
17019
47
    zval *value;
17020
47
    zend_string *str;
17021
17022
47
isset_dim_obj_array:
17023
47
    ht = Z_ARRVAL_P(container);
17024
47
isset_again:
17025
47
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
17026
29
      str = Z_STR_P(offset);
17027
29
      if (IS_CONST != IS_CONST) {
17028
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
17029
0
          goto num_index_prop;
17030
0
        }
17031
0
      }
17032
29
      value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
17033
29
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
17034
18
      hval = Z_LVAL_P(offset);
17035
18
num_index_prop:
17036
18
      value = zend_hash_index_find(ht, hval);
17037
18
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
17038
0
      offset = Z_REFVAL_P(offset);
17039
0
      goto isset_again;
17040
0
    } else {
17041
0
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
17042
0
      if (UNEXPECTED(EG(exception))) {
17043
0
        result = 0;
17044
0
        goto isset_dim_obj_exit;
17045
0
      }
17046
0
    }
17047
17048
47
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
17049
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
17050
47
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
17051
47
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
17052
17053
47
      if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
17054
        /* avoid exception check */
17055
17056
0
        ZEND_VM_SMART_BRANCH(result, 0);
17057
0
      }
17058
47
    } else {
17059
0
      result = (value == NULL || !i_zend_is_true(value));
17060
0
    }
17061
47
    goto isset_dim_obj_exit;
17062
262
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
17063
0
    container = Z_REFVAL_P(container);
17064
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17065
0
      goto isset_dim_obj_array;
17066
0
    }
17067
0
  }
17068
17069
262
  if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
17070
0
    offset++;
17071
0
  }
17072
262
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
17073
185
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
17074
185
  } else {
17075
77
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
17076
77
  }
17077
17078
309
isset_dim_obj_exit:
17079
17080
309
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17081
309
  ZEND_VM_SMART_BRANCH(result, 1);
17082
309
}
17083
17084
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17085
165
{
17086
165
  USE_OPLINE
17087
165
  zval *container;
17088
165
  int result;
17089
165
  zval *offset;
17090
165
  zend_string *name, *tmp_name;
17091
17092
165
  SAVE_OPLINE();
17093
165
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17094
165
  offset = RT_CONSTANT(opline, opline->op2);
17095
17096
165
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17097
165
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17098
121
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17099
0
      container = Z_REFVAL_P(container);
17100
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
17101
0
        result = (opline->extended_value & ZEND_ISEMPTY);
17102
0
        goto isset_object_finish;
17103
0
      }
17104
121
    } else {
17105
121
      result = (opline->extended_value & ZEND_ISEMPTY);
17106
121
      goto isset_object_finish;
17107
121
    }
17108
121
  }
17109
17110
44
  if (IS_CONST == IS_CONST) {
17111
44
    name = Z_STR_P(offset);
17112
44
  } else {
17113
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
17114
0
    if (UNEXPECTED(!name)) {
17115
0
      result = 0;
17116
0
      goto isset_object_finish;
17117
0
    }
17118
0
  }
17119
17120
44
  result =
17121
44
    (opline->extended_value & ZEND_ISEMPTY) ^
17122
44
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
17123
17124
44
  if (IS_CONST != IS_CONST) {
17125
0
    zend_tmp_string_release(tmp_name);
17126
0
  }
17127
17128
165
isset_object_finish:
17129
17130
165
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17131
165
  ZEND_VM_SMART_BRANCH(result, 1);
17132
165
}
17133
17134
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17135
9
{
17136
9
  USE_OPLINE
17137
17138
9
  zval *key, *subject;
17139
9
  HashTable *ht;
17140
9
  bool result;
17141
17142
9
  SAVE_OPLINE();
17143
17144
9
  key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17145
9
  subject = RT_CONSTANT(opline, opline->op2);
17146
17147
9
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
17148
9
array_key_exists_array:
17149
9
    ht = Z_ARRVAL_P(subject);
17150
9
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
17151
9
  } else {
17152
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
17153
0
      subject = Z_REFVAL_P(subject);
17154
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
17155
0
        goto array_key_exists_array;
17156
0
      }
17157
0
    }
17158
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
17159
0
    result = 0;
17160
0
  }
17161
17162
9
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17163
9
  ZEND_VM_SMART_BRANCH(result, 1);
17164
9
}
17165
17166
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17167
242
{
17168
242
  USE_OPLINE
17169
242
  zval *expr;
17170
242
  bool result;
17171
17172
242
  SAVE_OPLINE();
17173
242
  expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17174
17175
242
try_instanceof:
17176
242
  if (Z_TYPE_P(expr) == IS_OBJECT) {
17177
221
    zend_class_entry *ce;
17178
17179
221
    if (IS_CONST == IS_CONST) {
17180
221
      ce = CACHED_PTR(opline->extended_value);
17181
221
      if (UNEXPECTED(ce == NULL)) {
17182
113
        ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD);
17183
113
        if (EXPECTED(ce)) {
17184
96
          CACHE_PTR(opline->extended_value, ce);
17185
96
        }
17186
113
      }
17187
221
    } else if (IS_CONST == IS_UNUSED) {
17188
0
      ce = zend_fetch_class(NULL, opline->op2.num);
17189
0
      if (UNEXPECTED(ce == NULL)) {
17190
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17191
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
17192
0
        HANDLE_EXCEPTION();
17193
0
      }
17194
0
    } else {
17195
0
      ce = Z_CE_P(EX_VAR(opline->op2.var));
17196
0
    }
17197
221
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
17198
221
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
17199
0
    expr = Z_REFVAL_P(expr);
17200
0
    goto try_instanceof;
17201
21
  } else {
17202
21
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
17203
0
      ZVAL_UNDEFINED_OP1();
17204
0
    }
17205
21
    result = 0;
17206
21
  }
17207
242
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17208
242
  ZEND_VM_SMART_BRANCH(result, 1);
17209
242
}
17210
17211
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17212
1.95k
{
17213
1.95k
  USE_OPLINE
17214
1.95k
  zval *container, *dim, *value;
17215
1.95k
  zend_long offset;
17216
1.95k
  HashTable *ht;
17217
17218
1.95k
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17219
1.95k
  dim = RT_CONSTANT(opline, opline->op2);
17220
1.95k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17221
1.31k
fetch_dim_r_index_array:
17222
1.31k
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
17223
1.30k
      offset = Z_LVAL_P(dim);
17224
1.30k
    } else {
17225
6
      SAVE_OPLINE();
17226
6
      zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
17227
6
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17228
6
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17229
6
    }
17230
1.30k
    ht = Z_ARRVAL_P(container);
17231
1.30k
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
17232
1.14k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17233
1.14k
    if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17234
1.14k
      SAVE_OPLINE();
17235
1.14k
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17236
1.14k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17237
1.14k
    } else {
17238
0
      ZEND_VM_NEXT_OPCODE();
17239
0
    }
17240
1.14k
  } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17241
89
    container = Z_REFVAL_P(container);
17242
89
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17243
84
      goto fetch_dim_r_index_array;
17244
84
    } else {
17245
5
      goto fetch_dim_r_index_slow;
17246
5
    }
17247
634
  } else {
17248
639
fetch_dim_r_index_slow:
17249
639
    SAVE_OPLINE();
17250
639
    if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17251
0
      dim++;
17252
0
    }
17253
639
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17254
639
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17255
639
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17256
639
  }
17257
17258
163
fetch_dim_r_index_undef:
17259
163
  ZVAL_NULL(EX_VAR(opline->result.var));
17260
163
  SAVE_OPLINE();
17261
163
  zend_undefined_offset(offset);
17262
163
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17263
163
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17264
163
}
17265
17266
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17267
673
{
17268
673
  USE_OPLINE
17269
673
  zval *container, *dim, *value;
17270
673
  zend_long offset;
17271
673
  HashTable *ht;
17272
17273
673
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17274
673
  dim = EX_VAR(opline->op2.var);
17275
673
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17276
58
fetch_dim_r_index_array:
17277
58
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
17278
58
      offset = Z_LVAL_P(dim);
17279
58
    } else {
17280
0
      SAVE_OPLINE();
17281
0
      zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
17282
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17283
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17284
0
    }
17285
58
    ht = Z_ARRVAL_P(container);
17286
58
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
17287
49
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17288
49
    if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17289
49
      SAVE_OPLINE();
17290
49
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17291
49
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17292
49
    } else {
17293
0
      ZEND_VM_NEXT_OPCODE();
17294
0
    }
17295
615
  } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17296
0
    container = Z_REFVAL_P(container);
17297
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17298
0
      goto fetch_dim_r_index_array;
17299
0
    } else {
17300
0
      goto fetch_dim_r_index_slow;
17301
0
    }
17302
615
  } else {
17303
615
fetch_dim_r_index_slow:
17304
615
    SAVE_OPLINE();
17305
615
    if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17306
0
      dim++;
17307
0
    }
17308
615
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17309
615
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17310
615
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17311
615
  }
17312
17313
9
fetch_dim_r_index_undef:
17314
9
  ZVAL_NULL(EX_VAR(opline->result.var));
17315
9
  SAVE_OPLINE();
17316
9
  zend_undefined_offset(offset);
17317
9
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17318
9
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17319
9
}
17320
17321
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17322
26
{
17323
26
  USE_OPLINE
17324
26
  zval *op1, *op2;
17325
17326
26
  SAVE_OPLINE();
17327
26
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17328
26
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17329
26
  div_function(EX_VAR(opline->result.var), op1, op2);
17330
26
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17331
26
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17332
26
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17333
26
}
17334
17335
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17336
0
{
17337
0
  USE_OPLINE
17338
0
  zval *op1, *op2;
17339
17340
0
  SAVE_OPLINE();
17341
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17342
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17343
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
17344
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17345
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17346
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17347
0
}
17348
17349
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17350
9.50k
{
17351
9.50k
  USE_OPLINE
17352
9.50k
  zval *op1, *op2;
17353
17354
9.50k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17355
9.50k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17356
17357
9.50k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
17358
9.50k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
17359
3.60k
    zend_string *op1_str = Z_STR_P(op1);
17360
3.60k
    zend_string *op2_str = Z_STR_P(op2);
17361
3.60k
    zend_string *str;
17362
3.60k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
17363
17364
3.60k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17365
121
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17366
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
17367
121
      } else {
17368
121
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17369
121
      }
17370
121
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17371
121
        zend_string_release_ex(op1_str, 0);
17372
121
      }
17373
3.48k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17374
161
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17375
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
17376
161
      } else {
17377
161
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17378
161
      }
17379
161
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17380
161
        zend_string_release_ex(op2_str, 0);
17381
161
      }
17382
3.32k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
17383
3.32k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
17384
2.93k
      size_t len = ZSTR_LEN(op1_str);
17385
17386
2.93k
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
17387
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
17388
0
      }
17389
2.93k
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
17390
2.93k
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17391
2.93k
      GC_ADD_FLAGS(str, flags);
17392
2.93k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17393
2.93k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17394
2.93k
        zend_string_release_ex(op2_str, 0);
17395
2.93k
      }
17396
2.93k
    } else {
17397
393
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17398
393
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17399
393
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17400
393
      GC_ADD_FLAGS(str, flags);
17401
393
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17402
393
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17403
393
        zend_string_release_ex(op1_str, 0);
17404
393
      }
17405
393
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17406
393
        zend_string_release_ex(op2_str, 0);
17407
393
      }
17408
393
    }
17409
3.60k
    ZEND_VM_NEXT_OPCODE();
17410
5.89k
  } else {
17411
5.89k
    SAVE_OPLINE();
17412
17413
5.89k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
17414
0
      op1 = ZVAL_UNDEFINED_OP1();
17415
0
    }
17416
5.89k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
17417
0
      op2 = ZVAL_UNDEFINED_OP2();
17418
0
    }
17419
5.89k
    concat_function(EX_VAR(opline->result.var), op1, op2);
17420
5.89k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17421
5.89k
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17422
5.89k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17423
5.89k
  }
17424
9.50k
}
17425
17426
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17427
938
{
17428
938
  USE_OPLINE
17429
938
  zval *op1, *op2;
17430
938
  double d1, d2;
17431
17432
938
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17433
938
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17434
938
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17435
    /* pass */
17436
938
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17437
417
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17438
337
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17439
221
is_equal_true:
17440
221
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
17441
221
      } else {
17442
539
is_equal_false:
17443
539
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
17444
539
      }
17445
337
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17446
0
      d1 = (double)Z_LVAL_P(op1);
17447
0
      d2 = Z_DVAL_P(op2);
17448
0
      goto is_equal_double;
17449
0
    }
17450
521
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17451
398
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17452
353
      d1 = Z_DVAL_P(op1);
17453
353
      d2 = Z_DVAL_P(op2);
17454
398
is_equal_double:
17455
398
      if (d1 == d2) {
17456
56
        goto is_equal_true;
17457
342
      } else {
17458
342
        goto is_equal_false;
17459
342
      }
17460
398
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17461
45
      d1 = Z_DVAL_P(op1);
17462
45
      d2 = (double)Z_LVAL_P(op2);
17463
45
      goto is_equal_double;
17464
45
    }
17465
398
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17466
25
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17467
25
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17468
25
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17469
25
        zval_ptr_dtor_str(op1);
17470
25
      }
17471
25
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17472
25
        zval_ptr_dtor_str(op2);
17473
25
      }
17474
25
      if (result) {
17475
12
        goto is_equal_true;
17476
13
      } else {
17477
13
        goto is_equal_false;
17478
13
      }
17479
25
    }
17480
25
  }
17481
938
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17482
938
}
17483
17484
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17485
55
{
17486
55
  USE_OPLINE
17487
55
  zval *op1, *op2;
17488
55
  double d1, d2;
17489
17490
55
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17491
55
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17492
55
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17493
    /* pass */
17494
55
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17495
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17496
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17497
0
is_equal_true:
17498
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17499
0
      } else {
17500
0
is_equal_false:
17501
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17502
0
      }
17503
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17504
0
      d1 = (double)Z_LVAL_P(op1);
17505
0
      d2 = Z_DVAL_P(op2);
17506
0
      goto is_equal_double;
17507
0
    }
17508
55
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17509
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17510
0
      d1 = Z_DVAL_P(op1);
17511
0
      d2 = Z_DVAL_P(op2);
17512
0
is_equal_double:
17513
0
      if (d1 == d2) {
17514
0
        goto is_equal_true;
17515
0
      } else {
17516
0
        goto is_equal_false;
17517
0
      }
17518
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17519
0
      d1 = Z_DVAL_P(op1);
17520
0
      d2 = (double)Z_LVAL_P(op2);
17521
0
      goto is_equal_double;
17522
0
    }
17523
55
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17524
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17525
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17526
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17527
0
        zval_ptr_dtor_str(op1);
17528
0
      }
17529
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17530
0
        zval_ptr_dtor_str(op2);
17531
0
      }
17532
0
      if (result) {
17533
0
        goto is_equal_true;
17534
0
      } else {
17535
0
        goto is_equal_false;
17536
0
      }
17537
0
    }
17538
0
  }
17539
55
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17540
55
}
17541
17542
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17543
0
{
17544
0
  USE_OPLINE
17545
0
  zval *op1, *op2;
17546
0
  double d1, d2;
17547
17548
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17549
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17550
0
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17551
    /* pass */
17552
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17553
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17554
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17555
0
is_equal_true:
17556
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17557
0
      } else {
17558
0
is_equal_false:
17559
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17560
0
      }
17561
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17562
0
      d1 = (double)Z_LVAL_P(op1);
17563
0
      d2 = Z_DVAL_P(op2);
17564
0
      goto is_equal_double;
17565
0
    }
17566
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17567
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17568
0
      d1 = Z_DVAL_P(op1);
17569
0
      d2 = Z_DVAL_P(op2);
17570
0
is_equal_double:
17571
0
      if (d1 == d2) {
17572
0
        goto is_equal_true;
17573
0
      } else {
17574
0
        goto is_equal_false;
17575
0
      }
17576
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17577
0
      d1 = Z_DVAL_P(op1);
17578
0
      d2 = (double)Z_LVAL_P(op2);
17579
0
      goto is_equal_double;
17580
0
    }
17581
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17582
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17583
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17584
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17585
0
        zval_ptr_dtor_str(op1);
17586
0
      }
17587
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17588
0
        zval_ptr_dtor_str(op2);
17589
0
      }
17590
0
      if (result) {
17591
0
        goto is_equal_true;
17592
0
      } else {
17593
0
        goto is_equal_false;
17594
0
      }
17595
0
    }
17596
0
  }
17597
0
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17598
0
}
17599
17600
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17601
298
{
17602
298
  USE_OPLINE
17603
298
  zval *op1, *op2;
17604
298
  double d1, d2;
17605
17606
298
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17607
298
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17608
298
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17609
    /* pass */
17610
298
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17611
69
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17612
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17613
57
is_not_equal_true:
17614
57
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
17615
57
      } else {
17616
45
is_not_equal_false:
17617
45
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
17618
45
      }
17619
69
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17620
0
      d1 = (double)Z_LVAL_P(op1);
17621
0
      d2 = Z_DVAL_P(op2);
17622
0
      goto is_not_equal_double;
17623
0
    }
17624
229
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17625
67
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17626
0
      d1 = Z_DVAL_P(op1);
17627
0
      d2 = Z_DVAL_P(op2);
17628
0
is_not_equal_double:
17629
0
      if (d1 != d2) {
17630
0
        goto is_not_equal_true;
17631
0
      } else {
17632
0
        goto is_not_equal_false;
17633
0
      }
17634
67
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17635
0
      d1 = Z_DVAL_P(op1);
17636
0
      d2 = (double)Z_LVAL_P(op2);
17637
0
      goto is_not_equal_double;
17638
0
    }
17639
162
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17640
108
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17641
102
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17642
102
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17643
102
        zval_ptr_dtor_str(op1);
17644
102
      }
17645
102
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17646
102
        zval_ptr_dtor_str(op2);
17647
102
      }
17648
102
      if (!result) {
17649
57
        goto is_not_equal_true;
17650
57
      } else {
17651
45
        goto is_not_equal_false;
17652
45
      }
17653
102
    }
17654
108
  }
17655
298
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17656
298
}
17657
17658
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17659
103
{
17660
103
  USE_OPLINE
17661
103
  zval *op1, *op2;
17662
103
  double d1, d2;
17663
17664
103
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17665
103
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17666
103
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17667
    /* pass */
17668
103
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17669
13
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17670
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17671
0
is_not_equal_true:
17672
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17673
0
      } else {
17674
0
is_not_equal_false:
17675
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17676
0
      }
17677
13
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17678
0
      d1 = (double)Z_LVAL_P(op1);
17679
0
      d2 = Z_DVAL_P(op2);
17680
0
      goto is_not_equal_double;
17681
0
    }
17682
90
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17683
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17684
0
      d1 = Z_DVAL_P(op1);
17685
0
      d2 = Z_DVAL_P(op2);
17686
0
is_not_equal_double:
17687
0
      if (d1 != d2) {
17688
0
        goto is_not_equal_true;
17689
0
      } else {
17690
0
        goto is_not_equal_false;
17691
0
      }
17692
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17693
0
      d1 = Z_DVAL_P(op1);
17694
0
      d2 = (double)Z_LVAL_P(op2);
17695
0
      goto is_not_equal_double;
17696
0
    }
17697
90
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17698
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17699
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17700
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17701
0
        zval_ptr_dtor_str(op1);
17702
0
      }
17703
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17704
0
        zval_ptr_dtor_str(op2);
17705
0
      }
17706
0
      if (!result) {
17707
0
        goto is_not_equal_true;
17708
0
      } else {
17709
0
        goto is_not_equal_false;
17710
0
      }
17711
0
    }
17712
0
  }
17713
103
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17714
103
}
17715
17716
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17717
0
{
17718
0
  USE_OPLINE
17719
0
  zval *op1, *op2;
17720
0
  double d1, d2;
17721
17722
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17723
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17724
0
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17725
    /* pass */
17726
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17727
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17728
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17729
0
is_not_equal_true:
17730
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17731
0
      } else {
17732
0
is_not_equal_false:
17733
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17734
0
      }
17735
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17736
0
      d1 = (double)Z_LVAL_P(op1);
17737
0
      d2 = Z_DVAL_P(op2);
17738
0
      goto is_not_equal_double;
17739
0
    }
17740
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17741
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17742
0
      d1 = Z_DVAL_P(op1);
17743
0
      d2 = Z_DVAL_P(op2);
17744
0
is_not_equal_double:
17745
0
      if (d1 != d2) {
17746
0
        goto is_not_equal_true;
17747
0
      } else {
17748
0
        goto is_not_equal_false;
17749
0
      }
17750
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17751
0
      d1 = Z_DVAL_P(op1);
17752
0
      d2 = (double)Z_LVAL_P(op2);
17753
0
      goto is_not_equal_double;
17754
0
    }
17755
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17756
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17757
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17758
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17759
0
        zval_ptr_dtor_str(op1);
17760
0
      }
17761
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17762
0
        zval_ptr_dtor_str(op2);
17763
0
      }
17764
0
      if (!result) {
17765
0
        goto is_not_equal_true;
17766
0
      } else {
17767
0
        goto is_not_equal_false;
17768
0
      }
17769
0
    }
17770
0
  }
17771
0
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17772
0
}
17773
17774
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17775
0
{
17776
0
  USE_OPLINE
17777
0
  zval *op1, *op2;
17778
17779
0
  SAVE_OPLINE();
17780
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17781
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17782
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
17783
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17784
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17785
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17786
0
}
17787
17788
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17789
195
{
17790
195
  USE_OPLINE
17791
195
  zval *op1, *op2;
17792
17793
195
  SAVE_OPLINE();
17794
195
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17795
195
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17796
195
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
17797
195
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17798
195
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17799
195
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17800
195
}
17801
17802
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17803
1.19k
{
17804
1.19k
  USE_OPLINE
17805
1.19k
  zval *container, *dim, *value;
17806
17807
1.19k
  SAVE_OPLINE();
17808
1.19k
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17809
1.19k
  dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17810
1.19k
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17811
1.19k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17812
1.01k
fetch_dim_r_array:
17813
1.01k
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
17814
1.01k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17815
1.01k
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17816
0
      container = Z_REFVAL_P(container);
17817
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17818
0
        goto fetch_dim_r_array;
17819
0
      } else {
17820
0
        goto fetch_dim_r_slow;
17821
0
      }
17822
182
    } else {
17823
182
fetch_dim_r_slow:
17824
182
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17825
0
        dim++;
17826
0
      }
17827
182
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17828
182
    }
17829
1.19k
  } else {
17830
0
    zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
17831
0
  }
17832
1.19k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17833
1.19k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17834
1.19k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17835
1.19k
}
17836
17837
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17838
517
{
17839
517
  USE_OPLINE
17840
517
  zval *container;
17841
17842
517
  SAVE_OPLINE();
17843
517
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17844
517
  zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
17845
517
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17846
517
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17847
517
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17848
517
}
17849
17850
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17851
18
{
17852
18
  USE_OPLINE
17853
18
  zval *container;
17854
18
  void **cache_slot = NULL;
17855
17856
18
  SAVE_OPLINE();
17857
18
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17858
17859
18
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17860
18
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17861
18
    do {
17862
18
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17863
0
        container = Z_REFVAL_P(container);
17864
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17865
0
          break;
17866
0
        }
17867
0
      }
17868
18
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
17869
0
        ZVAL_UNDEFINED_OP1();
17870
0
      }
17871
18
      zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17872
18
      ZVAL_NULL(EX_VAR(opline->result.var));
17873
18
      goto fetch_obj_r_finish;
17874
18
    } while (0);
17875
18
  }
17876
17877
  /* here we are sure we are dealing with an object */
17878
0
  do {
17879
0
    zend_object *zobj = Z_OBJ_P(container);
17880
0
    zend_string *name, *tmp_name;
17881
0
    zval *retval;
17882
17883
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17884
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
17885
17886
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17887
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17888
17889
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17890
0
fetch_obj_r_simple:
17891
0
          retval = OBJ_PROP(zobj, prop_offset);
17892
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
17893
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17894
0
              goto fetch_obj_r_copy;
17895
0
            } else {
17896
0
fetch_obj_r_fast_copy:
17897
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17898
0
              ZEND_VM_NEXT_OPCODE();
17899
0
            }
17900
0
          }
17901
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
17902
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
17903
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
17904
0
            prop_offset = prop_info->offset;
17905
0
            goto fetch_obj_r_simple;
17906
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
17907
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
17908
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
17909
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
17910
17911
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
17912
0
            if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
17913
0
              GC_ADDREF(zobj);
17914
0
            }
17915
0
            if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
17916
0
              call_info |= ZEND_CALL_RELEASE_THIS;
17917
0
            }
17918
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
17919
0
            call->prev_execute_data = execute_data;
17920
0
            call->call = NULL;
17921
0
            call->return_value = EX_VAR(opline->result.var);
17922
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
17923
17924
0
            execute_data = call;
17925
0
            EG(current_execute_data) = execute_data;
17926
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
17927
17928
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
17929
            opline = hook->op_array.opcodes;
17930
#else
17931
0
            EX(opline) = hook->op_array.opcodes;
17932
0
#endif
17933
0
            LOAD_OPLINE_EX();
17934
17935
17936
0
            ZEND_VM_ENTER_EX();
17937
0
          }
17938
          /* Fall through to read_property for hooks. */
17939
0
        } else if (EXPECTED(zobj->properties != NULL)) {
17940
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
17941
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17942
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17943
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17944
17945
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17946
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17947
17948
0
              if (EXPECTED(p->key == name) ||
17949
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
17950
0
                   EXPECTED(p->key != NULL) &&
17951
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
17952
0
                retval = &p->val;
17953
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17954
0
                  goto fetch_obj_r_copy;
17955
0
                } else {
17956
0
                  goto fetch_obj_r_fast_copy;
17957
0
                }
17958
0
              }
17959
0
            }
17960
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17961
0
          }
17962
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
17963
0
          if (EXPECTED(retval)) {
17964
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17965
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17966
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17967
0
              goto fetch_obj_r_copy;
17968
0
            } else {
17969
0
              goto fetch_obj_r_fast_copy;
17970
0
            }
17971
0
          }
17972
0
        }
17973
0
      }
17974
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17975
0
    } else {
17976
0
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17977
0
      if (UNEXPECTED(!name)) {
17978
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
17979
0
        break;
17980
0
      }
17981
0
    }
17982
17983
0
#if ZEND_DEBUG
17984
    /* For non-standard object handlers, verify a declared property type in debug builds.
17985
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
17986
0
    zend_property_info *prop_info = NULL;
17987
0
    if (zobj->handlers->read_property != zend_std_read_property) {
17988
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
17989
0
    }
17990
0
#endif
17991
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
17992
0
#if ZEND_DEBUG
17993
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
17994
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
17995
0
      ZVAL_OPT_DEREF(retval);
17996
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
17997
0
    }
17998
0
#endif
17999
18000
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18001
0
      zend_tmp_string_release(tmp_name);
18002
0
    }
18003
18004
0
    if (retval != EX_VAR(opline->result.var)) {
18005
0
fetch_obj_r_copy:
18006
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18007
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
18008
0
      zend_unwrap_reference(retval);
18009
0
    }
18010
0
  } while (0);
18011
18012
18
fetch_obj_r_finish:
18013
18
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18014
18
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18015
18
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18016
18
}
18017
18018
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18019
7
{
18020
7
  USE_OPLINE
18021
7
  zval *container;
18022
7
  void **cache_slot = NULL;
18023
18024
7
  SAVE_OPLINE();
18025
7
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18026
18027
7
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18028
7
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18029
0
    do {
18030
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18031
0
        container = Z_REFVAL_P(container);
18032
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
18033
0
          break;
18034
0
        }
18035
0
      }
18036
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
18037
0
        ZVAL_UNDEFINED_OP2();
18038
0
      }
18039
0
      ZVAL_NULL(EX_VAR(opline->result.var));
18040
0
      goto fetch_obj_is_finish;
18041
0
    } while (0);
18042
0
  }
18043
18044
  /* here we are sure we are dealing with an object */
18045
7
  do {
18046
7
    zend_object *zobj = Z_OBJ_P(container);
18047
7
    zend_string *name, *tmp_name;
18048
7
    zval *retval;
18049
18050
7
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18051
0
      cache_slot = CACHE_ADDR(opline->extended_value);
18052
18053
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
18054
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
18055
18056
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
18057
0
fetch_obj_is_simple:
18058
0
          retval = OBJ_PROP(zobj, prop_offset);
18059
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
18060
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18061
0
              goto fetch_obj_is_copy;
18062
0
            } else {
18063
0
fetch_obj_is_fast_copy:
18064
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18065
0
              ZEND_VM_NEXT_OPCODE();
18066
0
            }
18067
0
          }
18068
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
18069
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
18070
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
18071
0
            prop_offset = prop_info->offset;
18072
0
            goto fetch_obj_is_simple;
18073
0
          }
18074
          /* Fall through to read_property for hooks. */
18075
0
        } else if (EXPECTED(zobj->properties != NULL)) {
18076
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
18077
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
18078
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
18079
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
18080
18081
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
18082
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
18083
18084
0
              if (EXPECTED(p->key == name) ||
18085
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
18086
0
                   EXPECTED(p->key != NULL) &&
18087
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
18088
0
                retval = &p->val;
18089
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18090
0
                  goto fetch_obj_is_copy;
18091
0
                } else {
18092
0
                  goto fetch_obj_is_fast_copy;
18093
0
                }
18094
0
              }
18095
0
            }
18096
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
18097
0
          }
18098
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
18099
0
          if (EXPECTED(retval)) {
18100
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
18101
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
18102
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18103
0
              goto fetch_obj_is_copy;
18104
0
            } else {
18105
0
              goto fetch_obj_is_fast_copy;
18106
0
            }
18107
0
          }
18108
0
        }
18109
0
      }
18110
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
18111
7
    } else {
18112
7
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
18113
7
      if (UNEXPECTED(!name)) {
18114
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
18115
0
        break;
18116
0
      }
18117
7
    }
18118
18119
7
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
18120
18121
7
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18122
7
      zend_tmp_string_release(tmp_name);
18123
7
    }
18124
18125
7
    if (retval != EX_VAR(opline->result.var)) {
18126
7
fetch_obj_is_copy:
18127
7
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18128
7
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
18129
0
      zend_unwrap_reference(retval);
18130
0
    }
18131
7
  } while (0);
18132
18133
7
fetch_obj_is_finish:
18134
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18135
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18136
7
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18137
7
}
18138
18139
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18140
5.85k
{
18141
5.85k
  USE_OPLINE
18142
5.85k
  zval *op1, *op2;
18143
5.85k
  zend_string *op1_str, *op2_str, *str;
18144
18145
18146
5.85k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18147
5.85k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18148
5.85k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
18149
5.85k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
18150
3.36k
    zend_string *op1_str = Z_STR_P(op1);
18151
3.36k
    zend_string *op2_str = Z_STR_P(op2);
18152
3.36k
    zend_string *str;
18153
3.36k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
18154
18155
3.36k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18156
18
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18157
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
18158
18
      } else {
18159
18
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18160
18
      }
18161
18
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18162
18
        zend_string_release_ex(op1_str, 0);
18163
18
      }
18164
3.34k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18165
23
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18166
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
18167
23
      } else {
18168
23
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18169
23
      }
18170
23
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18171
23
        zend_string_release_ex(op2_str, 0);
18172
23
      }
18173
3.32k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
18174
3.32k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
18175
3.22k
      size_t len = ZSTR_LEN(op1_str);
18176
18177
3.22k
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
18178
3.22k
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18179
3.22k
      GC_ADD_FLAGS(str, flags);
18180
3.22k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18181
3.22k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18182
3.21k
        zend_string_release_ex(op2_str, 0);
18183
3.21k
      }
18184
3.22k
    } else {
18185
99
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18186
99
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18187
99
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18188
99
      GC_ADD_FLAGS(str, flags);
18189
99
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18190
99
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18191
99
        zend_string_release_ex(op1_str, 0);
18192
99
      }
18193
99
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18194
99
        zend_string_release_ex(op2_str, 0);
18195
99
      }
18196
99
    }
18197
3.36k
    ZEND_VM_NEXT_OPCODE();
18198
3.36k
  }
18199
18200
5.85k
  SAVE_OPLINE();
18201
2.49k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18202
0
    op1_str = Z_STR_P(op1);
18203
2.49k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18204
1.19k
    op1_str = zend_string_copy(Z_STR_P(op1));
18205
1.30k
  } else {
18206
1.30k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18207
0
      ZVAL_UNDEFINED_OP1();
18208
0
    }
18209
1.30k
    op1_str = zval_get_string_func(op1);
18210
1.30k
  }
18211
2.49k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18212
0
    op2_str = Z_STR_P(op2);
18213
2.49k
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18214
0
    op2_str = zend_string_copy(Z_STR_P(op2));
18215
2.49k
  } else {
18216
2.49k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
18217
0
      ZVAL_UNDEFINED_OP2();
18218
0
    }
18219
2.49k
    op2_str = zval_get_string_func(op2);
18220
2.49k
  }
18221
2.49k
  do {
18222
2.49k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18223
2.49k
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18224
994
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18225
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
18226
0
            GC_ADDREF(op2_str);
18227
0
          }
18228
0
        }
18229
994
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18230
994
        zend_string_release_ex(op1_str, 0);
18231
994
        break;
18232
994
      }
18233
2.49k
    }
18234
1.50k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18235
1.50k
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18236
27
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18237
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
18238
0
            GC_ADDREF(op1_str);
18239
0
          }
18240
0
        }
18241
27
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18242
27
        zend_string_release_ex(op2_str, 0);
18243
27
        break;
18244
27
      }
18245
1.50k
    }
18246
1.47k
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18247
1.47k
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18248
1.47k
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18249
18250
1.47k
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
18251
1.47k
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18252
1.47k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18253
1.47k
      zend_string_release_ex(op1_str, 0);
18254
1.47k
    }
18255
1.47k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18256
1.47k
      zend_string_release_ex(op2_str, 0);
18257
1.47k
    }
18258
1.47k
  } while (0);
18259
2.49k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18260
2.49k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18261
2.49k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18262
2.49k
}
18263
18264
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18265
29
{
18266
29
  USE_OPLINE
18267
29
  zval *function_name;
18268
29
  zval *object;
18269
29
  zend_function *fbc;
18270
29
  zend_class_entry *called_scope;
18271
29
  zend_object *obj;
18272
29
  zend_execute_data *call;
18273
29
  uint32_t call_info;
18274
18275
29
  SAVE_OPLINE();
18276
18277
29
  object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18278
18279
29
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18280
29
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18281
29
  }
18282
18283
29
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
18284
29
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18285
0
    do {
18286
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
18287
0
        function_name = Z_REFVAL_P(function_name);
18288
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
18289
0
          break;
18290
0
        }
18291
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
18292
0
        ZVAL_UNDEFINED_OP2();
18293
0
        if (UNEXPECTED(EG(exception) != NULL)) {
18294
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18295
0
          HANDLE_EXCEPTION();
18296
0
        }
18297
0
      }
18298
0
      zend_throw_error(NULL, "Method name must be a string");
18299
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18300
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18301
0
      HANDLE_EXCEPTION();
18302
0
    } while (0);
18303
0
  }
18304
18305
29
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18306
0
    obj = Z_OBJ_P(object);
18307
29
  } else {
18308
29
    do {
18309
29
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18310
29
        obj = Z_OBJ_P(object);
18311
29
      } else {
18312
0
        if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
18313
0
          zend_reference *ref = Z_REF_P(object);
18314
18315
0
          object = &ref->val;
18316
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18317
0
            obj = Z_OBJ_P(object);
18318
0
            if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
18319
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
18320
0
                efree_size(ref, sizeof(zend_reference));
18321
0
              } else {
18322
0
                Z_ADDREF_P(object);
18323
0
              }
18324
0
            }
18325
0
            break;
18326
0
          }
18327
0
        }
18328
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
18329
0
          object = ZVAL_UNDEFINED_OP1();
18330
0
          if (UNEXPECTED(EG(exception) != NULL)) {
18331
0
            if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18332
0
              zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18333
0
            }
18334
0
            HANDLE_EXCEPTION();
18335
0
          }
18336
0
        }
18337
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18338
0
          function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18339
0
        }
18340
0
        zend_invalid_method_call(object, function_name);
18341
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18342
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18343
0
        HANDLE_EXCEPTION();
18344
0
      }
18345
29
    } while (0);
18346
29
  }
18347
18348
29
  called_scope = obj->ce;
18349
18350
29
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
18351
29
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
18352
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
18353
29
  } else {
18354
29
    zend_object *orig_obj = obj;
18355
18356
29
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18357
0
      function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18358
0
    }
18359
18360
    /* First, locate the function. */
18361
29
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
18362
29
    if (UNEXPECTED(fbc == NULL)) {
18363
0
      if (EXPECTED(!EG(exception))) {
18364
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
18365
0
      }
18366
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18367
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
18368
0
        zend_objects_store_del(orig_obj);
18369
0
      }
18370
0
      HANDLE_EXCEPTION();
18371
0
    }
18372
29
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
18373
29
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
18374
29
        EXPECTED(obj == orig_obj)) {
18375
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
18376
0
    }
18377
29
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
18378
0
      GC_ADDREF(obj); /* For $this pointer */
18379
0
      if (GC_DELREF(orig_obj) == 0) {
18380
0
        zend_objects_store_del(orig_obj);
18381
0
      }
18382
0
    }
18383
29
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
18384
5
      init_func_run_time_cache(&fbc->op_array);
18385
5
    }
18386
29
  }
18387
18388
29
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18389
29
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18390
29
  }
18391
18392
29
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
18393
29
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
18394
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
18395
0
      zend_objects_store_del(obj);
18396
0
      if (UNEXPECTED(EG(exception))) {
18397
0
        HANDLE_EXCEPTION();
18398
0
      }
18399
0
    }
18400
    /* call static method */
18401
0
    obj = (zend_object*)called_scope;
18402
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
18403
29
  } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
18404
29
    if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18405
0
      GC_ADDREF(obj); /* For $this pointer */
18406
0
    }
18407
    /* CV may be changed indirectly (e.g. when it's a reference) */
18408
29
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
18409
29
  }
18410
18411
29
  call = zend_vm_stack_push_call_frame(call_info,
18412
29
    fbc, opline->extended_value, obj);
18413
29
  call->prev_execute_data = EX(call);
18414
29
  EX(call) = call;
18415
18416
29
  ZEND_VM_NEXT_OPCODE();
18417
29
}
18418
18419
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18420
0
{
18421
0
  USE_OPLINE
18422
0
  zval *op1, *op2;
18423
0
  double d1, d2;
18424
18425
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18426
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18427
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
18428
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
18429
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
18430
0
case_true:
18431
0
        ZEND_VM_SMART_BRANCH_TRUE();
18432
0
      } else {
18433
0
case_false:
18434
0
        ZEND_VM_SMART_BRANCH_FALSE();
18435
0
      }
18436
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
18437
0
      d1 = (double)Z_LVAL_P(op1);
18438
0
      d2 = Z_DVAL_P(op2);
18439
0
      goto case_double;
18440
0
    }
18441
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
18442
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
18443
0
      d1 = Z_DVAL_P(op1);
18444
0
      d2 = Z_DVAL_P(op2);
18445
0
case_double:
18446
0
      if (d1 == d2) {
18447
0
        goto case_true;
18448
0
      } else {
18449
0
        goto case_false;
18450
0
      }
18451
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
18452
0
      d1 = Z_DVAL_P(op1);
18453
0
      d2 = (double)Z_LVAL_P(op2);
18454
0
      goto case_double;
18455
0
    }
18456
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18457
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18458
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
18459
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18460
0
      if (result) {
18461
0
        goto case_true;
18462
0
      } else {
18463
0
        goto case_false;
18464
0
      }
18465
0
    }
18466
0
  }
18467
0
  ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
18468
0
}
18469
18470
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18471
24
{
18472
24
  USE_OPLINE
18473
24
  zval *container;
18474
24
  bool result;
18475
24
  zend_ulong hval;
18476
24
  zval *offset;
18477
18478
24
  SAVE_OPLINE();
18479
24
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18480
24
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18481
18482
24
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18483
22
    HashTable *ht;
18484
22
    zval *value;
18485
22
    zend_string *str;
18486
18487
22
isset_dim_obj_array:
18488
22
    ht = Z_ARRVAL_P(container);
18489
22
isset_again:
18490
22
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
18491
0
      str = Z_STR_P(offset);
18492
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18493
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
18494
0
          goto num_index_prop;
18495
0
        }
18496
0
      }
18497
0
      value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18498
22
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
18499
19
      hval = Z_LVAL_P(offset);
18500
19
num_index_prop:
18501
19
      value = zend_hash_index_find(ht, hval);
18502
19
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
18503
0
      offset = Z_REFVAL_P(offset);
18504
0
      goto isset_again;
18505
3
    } else {
18506
3
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
18507
3
      if (UNEXPECTED(EG(exception))) {
18508
0
        result = 0;
18509
0
        goto isset_dim_obj_exit;
18510
0
      }
18511
3
    }
18512
18513
22
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
18514
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
18515
22
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
18516
22
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
18517
18518
22
      if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
18519
        /* avoid exception check */
18520
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18521
0
        ZEND_VM_SMART_BRANCH(result, 0);
18522
0
      }
18523
22
    } else {
18524
0
      result = (value == NULL || !i_zend_is_true(value));
18525
0
    }
18526
22
    goto isset_dim_obj_exit;
18527
22
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
18528
0
    container = Z_REFVAL_P(container);
18529
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18530
0
      goto isset_dim_obj_array;
18531
0
    }
18532
0
  }
18533
18534
2
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
18535
0
    offset++;
18536
0
  }
18537
2
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
18538
2
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
18539
2
  } else {
18540
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
18541
0
  }
18542
18543
24
isset_dim_obj_exit:
18544
24
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18545
24
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18546
24
  ZEND_VM_SMART_BRANCH(result, 1);
18547
24
}
18548
18549
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18550
15
{
18551
15
  USE_OPLINE
18552
15
  zval *container;
18553
15
  int result;
18554
15
  zval *offset;
18555
15
  zend_string *name, *tmp_name;
18556
18557
15
  SAVE_OPLINE();
18558
15
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18559
15
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18560
18561
15
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18562
15
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18563
15
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18564
0
      container = Z_REFVAL_P(container);
18565
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
18566
0
        result = (opline->extended_value & ZEND_ISEMPTY);
18567
0
        goto isset_object_finish;
18568
0
      }
18569
15
    } else {
18570
15
      result = (opline->extended_value & ZEND_ISEMPTY);
18571
15
      goto isset_object_finish;
18572
15
    }
18573
15
  }
18574
18575
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18576
0
    name = Z_STR_P(offset);
18577
0
  } else {
18578
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
18579
0
    if (UNEXPECTED(!name)) {
18580
0
      result = 0;
18581
0
      goto isset_object_finish;
18582
0
    }
18583
0
  }
18584
18585
0
  result =
18586
0
    (opline->extended_value & ZEND_ISEMPTY) ^
18587
0
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
18588
18589
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18590
0
    zend_tmp_string_release(tmp_name);
18591
0
  }
18592
18593
15
isset_object_finish:
18594
15
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18595
15
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18596
15
  ZEND_VM_SMART_BRANCH(result, 1);
18597
15
}
18598
18599
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18600
0
{
18601
0
  USE_OPLINE
18602
18603
0
  zval *key, *subject;
18604
0
  HashTable *ht;
18605
0
  bool result;
18606
18607
0
  SAVE_OPLINE();
18608
18609
0
  key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18610
0
  subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18611
18612
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
18613
0
array_key_exists_array:
18614
0
    ht = Z_ARRVAL_P(subject);
18615
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
18616
0
  } else {
18617
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
18618
0
      subject = Z_REFVAL_P(subject);
18619
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
18620
0
        goto array_key_exists_array;
18621
0
      }
18622
0
    }
18623
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
18624
0
    result = 0;
18625
0
  }
18626
18627
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18628
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18629
0
  ZEND_VM_SMART_BRANCH(result, 1);
18630
0
}
18631
18632
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18633
5
{
18634
5
  USE_OPLINE
18635
5
  zval *expr;
18636
5
  bool result;
18637
18638
5
  SAVE_OPLINE();
18639
5
  expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18640
18641
5
try_instanceof:
18642
5
  if (Z_TYPE_P(expr) == IS_OBJECT) {
18643
5
    zend_class_entry *ce;
18644
18645
5
    if (IS_VAR == IS_CONST) {
18646
0
      ce = CACHED_PTR(opline->extended_value);
18647
0
      if (UNEXPECTED(ce == NULL)) {
18648
0
        ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD);
18649
0
        if (EXPECTED(ce)) {
18650
0
          CACHE_PTR(opline->extended_value, ce);
18651
0
        }
18652
0
      }
18653
5
    } else if (IS_VAR == IS_UNUSED) {
18654
0
      ce = zend_fetch_class(NULL, opline->op2.num);
18655
0
      if (UNEXPECTED(ce == NULL)) {
18656
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18657
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
18658
0
        HANDLE_EXCEPTION();
18659
0
      }
18660
5
    } else {
18661
5
      ce = Z_CE_P(EX_VAR(opline->op2.var));
18662
5
    }
18663
5
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18664
5
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18665
0
    expr = Z_REFVAL_P(expr);
18666
0
    goto try_instanceof;
18667
0
  } else {
18668
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18669
0
      ZVAL_UNDEFINED_OP1();
18670
0
    }
18671
0
    result = 0;
18672
0
  }
18673
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18674
5
  ZEND_VM_SMART_BRANCH(result, 1);
18675
5
}
18676
18677
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_EX int type)
18678
19.3k
{
18679
19.3k
  USE_OPLINE
18680
19.3k
  zval *varname;
18681
19.3k
  zval *retval;
18682
19.3k
  zend_string *name, *tmp_name;
18683
19.3k
  HashTable *target_symbol_table;
18684
18685
19.3k
  SAVE_OPLINE();
18686
19.3k
  varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18687
18688
19.3k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18689
0
    name = Z_STR_P(varname);
18690
19.3k
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18691
5.83k
    name = Z_STR_P(varname);
18692
5.83k
    tmp_name = NULL;
18693
13.5k
  } else {
18694
13.5k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18695
0
      ZVAL_UNDEFINED_OP1();
18696
0
    }
18697
13.5k
    name = zval_try_get_tmp_string(varname, &tmp_name);
18698
13.5k
    if (UNEXPECTED(!name)) {
18699
10
      if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18700
5
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18701
5
      }
18702
10
      ZVAL_UNDEF(EX_VAR(opline->result.var));
18703
10
      HANDLE_EXCEPTION();
18704
10
    }
18705
13.5k
  }
18706
18707
19.3k
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18708
19.3k
  retval = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18709
19.3k
  if (retval == NULL) {
18710
15.3k
    if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18711
0
fetch_this:
18712
0
      zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
18713
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18714
0
        zend_tmp_string_release(tmp_name);
18715
0
      }
18716
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18717
0
    }
18718
15.3k
    if (type == BP_VAR_W) {
18719
3.74k
      retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
18720
11.6k
    } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18721
0
      retval = &EG(uninitialized_zval);
18722
11.6k
    } else {
18723
11.6k
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18724
        /* Keep name alive in case an error handler tries to free it. */
18725
0
        zend_string_addref(name);
18726
0
      }
18727
11.6k
      zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18728
11.6k
        (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18729
11.6k
      if (type == BP_VAR_RW && !EG(exception)) {
18730
179
        retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
18731
11.4k
      } else {
18732
11.4k
        retval = &EG(uninitialized_zval);
18733
11.4k
      }
18734
11.6k
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18735
0
        zend_string_release(name);
18736
0
      }
18737
11.6k
    }
18738
  /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
18739
15.3k
  } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
18740
156
    retval = Z_INDIRECT_P(retval);
18741
156
    if (Z_TYPE_P(retval) == IS_UNDEF) {
18742
50
      if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18743
0
        goto fetch_this;
18744
0
      }
18745
50
      if (type == BP_VAR_W) {
18746
10
        ZVAL_NULL(retval);
18747
40
      } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18748
0
        retval = &EG(uninitialized_zval);
18749
40
      } else {
18750
40
        zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18751
40
          (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18752
40
        if (type == BP_VAR_RW && !EG(exception)) {
18753
0
          ZVAL_NULL(retval);
18754
40
        } else {
18755
40
          retval = &EG(uninitialized_zval);
18756
40
        }
18757
40
      }
18758
50
    }
18759
156
  }
18760
18761
19.3k
  if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18762
19.3k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18763
19.3k
  }
18764
18765
19.3k
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18766
19.3k
    zend_tmp_string_release(tmp_name);
18767
19.3k
  }
18768
18769
19.3k
  ZEND_ASSERT(retval != NULL);
18770
19.3k
  if (type == BP_VAR_R || type == BP_VAR_IS) {
18771
13.2k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18772
13.2k
  } else {
18773
6.09k
    ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
18774
6.09k
  }
18775
19.3k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18776
19.3k
}
18777
18778
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18779
13.2k
{
18780
13.2k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R));
18781
13.2k
}
18782
18783
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18784
4.52k
{
18785
4.52k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W));
18786
4.52k
}
18787
18788
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18789
1.57k
{
18790
1.57k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW));
18791
1.57k
}
18792
18793
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18794
2
{
18795
2
  int fetch_type =
18796
2
    (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
18797
2
      BP_VAR_W : BP_VAR_R;
18798
2
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type));
18799
2
}
18800
18801
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18802
0
{
18803
0
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET));
18804
0
}
18805
18806
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18807
4
{
18808
4
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS));
18809
4
}
18810
18811
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
18812
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18813
113k
{
18814
113k
  USE_OPLINE
18815
113k
  zval *value, *arg;
18816
18817
113k
  if (IS_UNUSED == IS_CONST) {
18818
0
    SAVE_OPLINE();
18819
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
18820
0
    uint32_t arg_num;
18821
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
18822
0
    if (UNEXPECTED(!arg)) {
18823
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18824
0
      HANDLE_EXCEPTION();
18825
0
    }
18826
113k
  } else {
18827
113k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
18828
113k
  }
18829
18830
113k
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18831
113k
  ZVAL_COPY_VALUE(arg, value);
18832
113k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18833
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
18834
0
      Z_ADDREF_P(arg);
18835
0
    }
18836
0
  }
18837
113k
  ZEND_VM_NEXT_OPCODE();
18838
113k
}
18839
18840
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18841
5
{
18842
5
  USE_OPLINE
18843
5
  zval *varname;
18844
5
  zend_string *name, *tmp_name;
18845
5
  HashTable *target_symbol_table;
18846
18847
5
  SAVE_OPLINE();
18848
18849
5
  varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18850
18851
5
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18852
0
    name = Z_STR_P(varname);
18853
5
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18854
5
    name = Z_STR_P(varname);
18855
5
    tmp_name = NULL;
18856
5
  } else {
18857
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18858
0
      varname = ZVAL_UNDEFINED_OP1();
18859
0
    }
18860
0
    name = zval_try_get_tmp_string(varname, &tmp_name);
18861
0
    if (UNEXPECTED(!name)) {
18862
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18863
0
      HANDLE_EXCEPTION();
18864
0
    }
18865
0
  }
18866
18867
5
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18868
5
  zend_hash_del_ind(target_symbol_table, name);
18869
18870
5
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18871
5
    zend_tmp_string_release(tmp_name);
18872
5
  }
18873
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18874
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18875
5
}
18876
18877
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
18878
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18879
5
{
18880
5
  USE_OPLINE
18881
5
  zval *value;
18882
5
  bool result;
18883
5
  zval *varname;
18884
5
  zend_string *name, *tmp_name;
18885
5
  HashTable *target_symbol_table;
18886
18887
5
  SAVE_OPLINE();
18888
5
  varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18889
5
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18890
0
    name = Z_STR_P(varname);
18891
5
  } else {
18892
5
    name = zval_get_tmp_string(varname, &tmp_name);
18893
5
  }
18894
18895
5
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18896
5
  value = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18897
18898
5
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18899
5
    zend_tmp_string_release(tmp_name);
18900
5
  }
18901
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18902
18903
5
  if (!value) {
18904
5
    result = (opline->extended_value & ZEND_ISEMPTY);
18905
5
  } else {
18906
0
    if (Z_TYPE_P(value) == IS_INDIRECT) {
18907
0
      value = Z_INDIRECT_P(value);
18908
0
    }
18909
0
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
18910
0
      if (Z_ISREF_P(value)) {
18911
0
        value = Z_REFVAL_P(value);
18912
0
      }
18913
0
      result = Z_TYPE_P(value) > IS_NULL;
18914
0
    } else {
18915
0
      result = !i_zend_is_true(value);
18916
0
    }
18917
0
  }
18918
18919
5
  ZEND_VM_SMART_BRANCH(result, true);
18920
5
}
18921
18922
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
18923
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18924
5
{
18925
5
  USE_OPLINE
18926
5
  zval *expr;
18927
5
  bool result;
18928
18929
5
  SAVE_OPLINE();
18930
5
  expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18931
18932
5
try_instanceof:
18933
5
  if (Z_TYPE_P(expr) == IS_OBJECT) {
18934
5
    zend_class_entry *ce;
18935
18936
5
    if (IS_UNUSED == IS_CONST) {
18937
0
      ce = CACHED_PTR(opline->extended_value);
18938
0
      if (UNEXPECTED(ce == NULL)) {
18939
0
        ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD);
18940
0
        if (EXPECTED(ce)) {
18941
0
          CACHE_PTR(opline->extended_value, ce);
18942
0
        }
18943
0
      }
18944
5
    } else if (IS_UNUSED == IS_UNUSED) {
18945
5
      ce = zend_fetch_class(NULL, opline->op2.num);
18946
5
      if (UNEXPECTED(ce == NULL)) {
18947
5
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18948
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
18949
5
        HANDLE_EXCEPTION();
18950
5
      }
18951
5
    } else {
18952
0
      ce = Z_CE_P(EX_VAR(opline->op2.var));
18953
0
    }
18954
0
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18955
0
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18956
0
    expr = Z_REFVAL_P(expr);
18957
0
    goto try_instanceof;
18958
0
  } else {
18959
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18960
0
      ZVAL_UNDEFINED_OP1();
18961
0
    }
18962
0
    result = 0;
18963
0
  }
18964
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18965
0
  ZEND_VM_SMART_BRANCH(result, 1);
18966
0
}
18967
18968
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18969
151
{
18970
151
  USE_OPLINE
18971
151
  zval *op1;
18972
151
  zend_long count;
18973
18974
151
  SAVE_OPLINE();
18975
151
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18976
18977
151
  while (1) {
18978
151
    if (Z_TYPE_P(op1) == IS_ARRAY) {
18979
148
      count = zend_hash_num_elements(Z_ARRVAL_P(op1));
18980
148
      break;
18981
148
    } else if (Z_TYPE_P(op1) == IS_OBJECT) {
18982
0
      zend_object *zobj = Z_OBJ_P(op1);
18983
18984
      /* first, we check if the handler is defined */
18985
0
      if (zobj->handlers->count_elements) {
18986
0
        if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
18987
0
          break;
18988
0
        }
18989
0
        if (UNEXPECTED(EG(exception))) {
18990
0
          count = 0;
18991
0
          break;
18992
0
        }
18993
0
      }
18994
18995
      /* if not and the object implements Countable we call its count() method */
18996
0
      if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
18997
0
        zval retval;
18998
18999
0
        zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
19000
0
        zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
19001
0
        count = zval_get_long(&retval);
19002
0
        zval_ptr_dtor(&retval);
19003
0
        break;
19004
0
      }
19005
19006
      /* If There's no handler and it doesn't implement Countable then emit a TypeError */
19007
3
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
19008
0
      op1 = Z_REFVAL_P(op1);
19009
0
      continue;
19010
3
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19011
0
      ZVAL_UNDEFINED_OP1();
19012
0
    }
19013
3
    count = 0;
19014
3
    zend_type_error("%s(): Argument #1 ($value) must be of type Countable|array, %s given", opline->extended_value ? "sizeof" : "count", zend_zval_value_name(op1));
19015
3
    break;
19016
151
  }
19017
19018
151
  ZVAL_LONG(EX_VAR(opline->result.var), count);
19019
151
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19020
151
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19021
151
}
19022
19023
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19024
35
{
19025
35
  USE_OPLINE
19026
35
  zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC));
19027
35
  ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
19028
35
  if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
19029
30
    SAVE_OPLINE();
19030
30
    zend_array_destroy(ht);
19031
30
    if (EG(exception)) {
19032
25
      HANDLE_EXCEPTION();
19033
25
    }
19034
30
  }
19035
10
  ZEND_VM_NEXT_OPCODE();
19036
10
}
19037
19038
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19039
302
{
19040
302
  USE_OPLINE
19041
19042
302
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
19043
0
    SAVE_OPLINE();
19044
0
    if (UNEXPECTED(!EX(func)->common.scope)) {
19045
0
      zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
19046
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
19047
0
      HANDLE_EXCEPTION();
19048
0
    } else {
19049
0
      zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
19050
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
19051
0
      if (UNEXPECTED(EG(exception))) {
19052
0
        HANDLE_EXCEPTION();
19053
0
      }
19054
0
      ZEND_VM_NEXT_OPCODE();
19055
0
    }
19056
302
  } else {
19057
302
    zval *op1;
19058
19059
302
    SAVE_OPLINE();
19060
302
    op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19061
302
    while (1) {
19062
302
      if (Z_TYPE_P(op1) == IS_OBJECT) {
19063
295
        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
19064
295
      } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
19065
0
        op1 = Z_REFVAL_P(op1);
19066
0
        continue;
19067
7
      } else {
19068
7
        if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19069
0
          ZVAL_UNDEFINED_OP1();
19070
0
        }
19071
7
        zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
19072
7
        ZVAL_UNDEF(EX_VAR(opline->result.var));
19073
7
      }
19074
302
      break;
19075
302
    }
19076
302
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19077
302
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19078
302
  }
19079
302
}
19080
19081
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19082
984
{
19083
984
  USE_OPLINE
19084
984
  zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19085
984
  zval *result = EX_VAR(opline->result.var);
19086
984
  ZVAL_COPY(result, value);
19087
984
  ZEND_VM_NEXT_OPCODE();
19088
984
}
19089
19090
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19091
0
{
19092
0
  USE_OPLINE
19093
0
  zval *op1, *op2;
19094
19095
0
  SAVE_OPLINE();
19096
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19097
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19098
0
  div_function(EX_VAR(opline->result.var), op1, op2);
19099
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19100
19101
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19102
0
}
19103
19104
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19105
0
{
19106
0
  USE_OPLINE
19107
0
  zval *op1, *op2;
19108
19109
0
  SAVE_OPLINE();
19110
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19111
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19112
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
19113
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19114
19115
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19116
0
}
19117
19118
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19119
1.41k
{
19120
1.41k
  USE_OPLINE
19121
1.41k
  zval *op1, *op2;
19122
19123
1.41k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19124
1.41k
  op2 = EX_VAR(opline->op2.var);
19125
19126
1.41k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
19127
1.41k
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
19128
632
    zend_string *op1_str = Z_STR_P(op1);
19129
632
    zend_string *op2_str = Z_STR_P(op2);
19130
632
    zend_string *str;
19131
632
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
19132
19133
632
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19134
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
19135
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
19136
0
      } else {
19137
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19138
0
      }
19139
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19140
0
        zend_string_release_ex(op1_str, 0);
19141
0
      }
19142
632
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19143
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
19144
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
19145
0
      } else {
19146
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19147
0
      }
19148
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19149
0
        zend_string_release_ex(op2_str, 0);
19150
0
      }
19151
632
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
19152
632
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
19153
620
      size_t len = ZSTR_LEN(op1_str);
19154
19155
620
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
19156
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
19157
0
      }
19158
620
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
19159
620
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19160
620
      GC_ADD_FLAGS(str, flags);
19161
620
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19162
620
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19163
0
        zend_string_release_ex(op2_str, 0);
19164
0
      }
19165
620
    } else {
19166
12
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19167
12
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19168
12
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19169
12
      GC_ADD_FLAGS(str, flags);
19170
12
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19171
12
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19172
12
        zend_string_release_ex(op1_str, 0);
19173
12
      }
19174
12
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19175
0
        zend_string_release_ex(op2_str, 0);
19176
0
      }
19177
12
    }
19178
632
    ZEND_VM_NEXT_OPCODE();
19179
779
  } else {
19180
779
    SAVE_OPLINE();
19181
19182
779
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19183
0
      op1 = ZVAL_UNDEFINED_OP1();
19184
0
    }
19185
779
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
19186
649
      op2 = ZVAL_UNDEFINED_OP2();
19187
649
    }
19188
779
    concat_function(EX_VAR(opline->result.var), op1, op2);
19189
779
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19190
19191
779
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19192
779
  }
19193
1.41k
}
19194
19195
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19196
4
{
19197
4
  USE_OPLINE
19198
4
  zval *op1, *op2;
19199
19200
4
  SAVE_OPLINE();
19201
4
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19202
4
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19203
4
  compare_function(EX_VAR(opline->result.var), op1, op2);
19204
4
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19205
19206
4
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19207
4
}
19208
19209
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19210
524
{
19211
524
  USE_OPLINE
19212
524
  zval *container, *dim, *value;
19213
19214
524
  SAVE_OPLINE();
19215
524
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19216
524
  dim = EX_VAR(opline->op2.var);
19217
524
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19218
524
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19219
410
fetch_dim_r_array:
19220
410
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
19221
410
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
19222
410
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
19223
0
      container = Z_REFVAL_P(container);
19224
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19225
0
        goto fetch_dim_r_array;
19226
0
      } else {
19227
0
        goto fetch_dim_r_slow;
19228
0
      }
19229
114
    } else {
19230
114
fetch_dim_r_slow:
19231
114
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
19232
0
        dim++;
19233
0
      }
19234
114
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
19235
114
    }
19236
524
  } else {
19237
0
    zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
19238
0
  }
19239
19240
524
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19241
524
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19242
524
}
19243
19244
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19245
0
{
19246
0
  USE_OPLINE
19247
0
  zval *container;
19248
19249
0
  SAVE_OPLINE();
19250
0
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19251
0
  zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
19252
19253
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19254
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19255
0
}
19256
19257
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19258
2
{
19259
2
  USE_OPLINE
19260
2
  zval *container;
19261
2
  void **cache_slot = NULL;
19262
19263
2
  SAVE_OPLINE();
19264
2
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19265
19266
2
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19267
2
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19268
2
    do {
19269
2
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19270
0
        container = Z_REFVAL_P(container);
19271
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
19272
0
          break;
19273
0
        }
19274
0
      }
19275
2
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
19276
0
        ZVAL_UNDEFINED_OP1();
19277
0
      }
19278
2
      zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19279
2
      ZVAL_NULL(EX_VAR(opline->result.var));
19280
2
      goto fetch_obj_r_finish;
19281
2
    } while (0);
19282
2
  }
19283
19284
  /* here we are sure we are dealing with an object */
19285
0
  do {
19286
0
    zend_object *zobj = Z_OBJ_P(container);
19287
0
    zend_string *name, *tmp_name;
19288
0
    zval *retval;
19289
19290
0
    if (IS_CV == IS_CONST) {
19291
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
19292
19293
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
19294
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
19295
19296
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
19297
0
fetch_obj_r_simple:
19298
0
          retval = OBJ_PROP(zobj, prop_offset);
19299
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
19300
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19301
0
              goto fetch_obj_r_copy;
19302
0
            } else {
19303
0
fetch_obj_r_fast_copy:
19304
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19305
0
              ZEND_VM_NEXT_OPCODE();
19306
0
            }
19307
0
          }
19308
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
19309
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
19310
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
19311
0
            prop_offset = prop_info->offset;
19312
0
            goto fetch_obj_r_simple;
19313
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
19314
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
19315
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
19316
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
19317
19318
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19319
0
            if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
19320
0
              GC_ADDREF(zobj);
19321
0
            }
19322
0
            if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
19323
0
              call_info |= ZEND_CALL_RELEASE_THIS;
19324
0
            }
19325
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
19326
0
            call->prev_execute_data = execute_data;
19327
0
            call->call = NULL;
19328
0
            call->return_value = EX_VAR(opline->result.var);
19329
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
19330
19331
0
            execute_data = call;
19332
0
            EG(current_execute_data) = execute_data;
19333
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
19334
19335
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
19336
            opline = hook->op_array.opcodes;
19337
#else
19338
0
            EX(opline) = hook->op_array.opcodes;
19339
0
#endif
19340
0
            LOAD_OPLINE_EX();
19341
19342
19343
0
            ZEND_VM_ENTER_EX();
19344
0
          }
19345
          /* Fall through to read_property for hooks. */
19346
0
        } else if (EXPECTED(zobj->properties != NULL)) {
19347
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
19348
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19349
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
19350
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
19351
19352
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
19353
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
19354
19355
0
              if (EXPECTED(p->key == name) ||
19356
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
19357
0
                   EXPECTED(p->key != NULL) &&
19358
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
19359
0
                retval = &p->val;
19360
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19361
0
                  goto fetch_obj_r_copy;
19362
0
                } else {
19363
0
                  goto fetch_obj_r_fast_copy;
19364
0
                }
19365
0
              }
19366
0
            }
19367
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
19368
0
          }
19369
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
19370
0
          if (EXPECTED(retval)) {
19371
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
19372
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
19373
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19374
0
              goto fetch_obj_r_copy;
19375
0
            } else {
19376
0
              goto fetch_obj_r_fast_copy;
19377
0
            }
19378
0
          }
19379
0
        }
19380
0
      }
19381
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19382
0
    } else {
19383
0
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
19384
0
      if (UNEXPECTED(!name)) {
19385
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
19386
0
        break;
19387
0
      }
19388
0
    }
19389
19390
0
#if ZEND_DEBUG
19391
    /* For non-standard object handlers, verify a declared property type in debug builds.
19392
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
19393
0
    zend_property_info *prop_info = NULL;
19394
0
    if (zobj->handlers->read_property != zend_std_read_property) {
19395
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
19396
0
    }
19397
0
#endif
19398
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
19399
0
#if ZEND_DEBUG
19400
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
19401
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
19402
0
      ZVAL_OPT_DEREF(retval);
19403
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
19404
0
    }
19405
0
#endif
19406
19407
0
    if (IS_CV != IS_CONST) {
19408
0
      zend_tmp_string_release(tmp_name);
19409
0
    }
19410
19411
0
    if (retval != EX_VAR(opline->result.var)) {
19412
0
fetch_obj_r_copy:
19413
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19414
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
19415
0
      zend_unwrap_reference(retval);
19416
0
    }
19417
0
  } while (0);
19418
19419
2
fetch_obj_r_finish:
19420
19421
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19422
2
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19423
2
}
19424
19425
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19426
0
{
19427
0
  USE_OPLINE
19428
0
  zval *container;
19429
0
  void **cache_slot = NULL;
19430
19431
0
  SAVE_OPLINE();
19432
0
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19433
19434
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19435
0
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19436
0
    do {
19437
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19438
0
        container = Z_REFVAL_P(container);
19439
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
19440
0
          break;
19441
0
        }
19442
0
      }
19443
0
      if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
19444
0
        ZVAL_UNDEFINED_OP2();
19445
0
      }
19446
0
      ZVAL_NULL(EX_VAR(opline->result.var));
19447
0
      goto fetch_obj_is_finish;
19448
0
    } while (0);
19449
0
  }
19450
19451
  /* here we are sure we are dealing with an object */
19452
0
  do {
19453
0
    zend_object *zobj = Z_OBJ_P(container);
19454
0
    zend_string *name, *tmp_name;
19455
0
    zval *retval;
19456
19457
0
    if (IS_CV == IS_CONST) {
19458
0
      cache_slot = CACHE_ADDR(opline->extended_value);
19459
19460
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
19461
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
19462
19463
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
19464
0
fetch_obj_is_simple:
19465
0
          retval = OBJ_PROP(zobj, prop_offset);
19466
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
19467
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19468
0
              goto fetch_obj_is_copy;
19469
0
            } else {
19470
0
fetch_obj_is_fast_copy:
19471
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19472
0
              ZEND_VM_NEXT_OPCODE();
19473
0
            }
19474
0
          }
19475
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
19476
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
19477
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
19478
0
            prop_offset = prop_info->offset;
19479
0
            goto fetch_obj_is_simple;
19480
0
          }
19481
          /* Fall through to read_property for hooks. */
19482
0
        } else if (EXPECTED(zobj->properties != NULL)) {
19483
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
19484
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19485
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
19486
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
19487
19488
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
19489
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
19490
19491
0
              if (EXPECTED(p->key == name) ||
19492
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
19493
0
                   EXPECTED(p->key != NULL) &&
19494
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
19495
0
                retval = &p->val;
19496
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19497
0
                  goto fetch_obj_is_copy;
19498
0
                } else {
19499
0
                  goto fetch_obj_is_fast_copy;
19500
0
                }
19501
0
              }
19502
0
            }
19503
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
19504
0
          }
19505
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
19506
0
          if (EXPECTED(retval)) {
19507
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
19508
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
19509
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19510
0
              goto fetch_obj_is_copy;
19511
0
            } else {
19512
0
              goto fetch_obj_is_fast_copy;
19513
0
            }
19514
0
          }
19515
0
        }
19516
0
      }
19517
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19518
0
    } else {
19519
0
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
19520
0
      if (UNEXPECTED(!name)) {
19521
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
19522
0
        break;
19523
0
      }
19524
0
    }
19525
19526
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
19527
19528
0
    if (IS_CV != IS_CONST) {
19529
0
      zend_tmp_string_release(tmp_name);
19530
0
    }
19531
19532
0
    if (retval != EX_VAR(opline->result.var)) {
19533
0
fetch_obj_is_copy:
19534
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19535
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
19536
0
      zend_unwrap_reference(retval);
19537
0
    }
19538
0
  } while (0);
19539
19540
0
fetch_obj_is_finish:
19541
19542
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19543
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19544
0
}
19545
19546
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19547
155
{
19548
155
  USE_OPLINE
19549
155
  zval *op1, *op2;
19550
155
  zend_string *op1_str, *op2_str, *str;
19551
19552
19553
155
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19554
155
  op2 = EX_VAR(opline->op2.var);
19555
155
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
19556
155
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
19557
19
    zend_string *op1_str = Z_STR_P(op1);
19558
19
    zend_string *op2_str = Z_STR_P(op2);
19559
19
    zend_string *str;
19560
19
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
19561
19562
19
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19563
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
19564
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
19565
0
      } else {
19566
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19567
0
      }
19568
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19569
0
        zend_string_release_ex(op1_str, 0);
19570
0
      }
19571
19
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19572
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
19573
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
19574
0
      } else {
19575
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19576
0
      }
19577
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19578
0
        zend_string_release_ex(op2_str, 0);
19579
0
      }
19580
19
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
19581
19
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
19582
19
      size_t len = ZSTR_LEN(op1_str);
19583
19584
19
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
19585
19
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19586
19
      GC_ADD_FLAGS(str, flags);
19587
19
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19588
19
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19589
0
        zend_string_release_ex(op2_str, 0);
19590
0
      }
19591
19
    } else {
19592
0
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19593
0
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19594
0
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19595
0
      GC_ADD_FLAGS(str, flags);
19596
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19597
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19598
0
        zend_string_release_ex(op1_str, 0);
19599
0
      }
19600
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19601
0
        zend_string_release_ex(op2_str, 0);
19602
0
      }
19603
0
    }
19604
19
    ZEND_VM_NEXT_OPCODE();
19605
19
  }
19606
19607
155
  SAVE_OPLINE();
19608
136
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
19609
0
    op1_str = Z_STR_P(op1);
19610
136
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19611
130
    op1_str = zend_string_copy(Z_STR_P(op1));
19612
130
  } else {
19613
6
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19614
0
      ZVAL_UNDEFINED_OP1();
19615
0
    }
19616
6
    op1_str = zval_get_string_func(op1);
19617
6
  }
19618
136
  if (IS_CV == IS_CONST) {
19619
0
    op2_str = Z_STR_P(op2);
19620
136
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19621
0
    op2_str = zend_string_copy(Z_STR_P(op2));
19622
136
  } else {
19623
136
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
19624
130
      ZVAL_UNDEFINED_OP2();
19625
130
    }
19626
136
    op2_str = zval_get_string_func(op2);
19627
136
  }
19628
136
  do {
19629
136
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19630
136
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19631
131
        if (IS_CV == IS_CONST) {
19632
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
19633
0
            GC_ADDREF(op2_str);
19634
0
          }
19635
0
        }
19636
131
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19637
131
        zend_string_release_ex(op1_str, 0);
19638
131
        break;
19639
131
      }
19640
136
    }
19641
5
    if (IS_CV != IS_CONST) {
19642
5
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19643
5
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
19644
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
19645
0
            GC_ADDREF(op1_str);
19646
0
          }
19647
0
        }
19648
5
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19649
5
        zend_string_release_ex(op2_str, 0);
19650
5
        break;
19651
5
      }
19652
5
    }
19653
0
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19654
0
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19655
0
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19656
19657
0
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
19658
0
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19659
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19660
0
      zend_string_release_ex(op1_str, 0);
19661
0
    }
19662
0
    if (IS_CV != IS_CONST) {
19663
0
      zend_string_release_ex(op2_str, 0);
19664
0
    }
19665
0
  } while (0);
19666
136
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19667
19668
136
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19669
136
}
19670
19671
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19672
92
{
19673
92
  USE_OPLINE
19674
92
  zval *function_name;
19675
92
  zval *object;
19676
92
  zend_function *fbc;
19677
92
  zend_class_entry *called_scope;
19678
92
  zend_object *obj;
19679
92
  zend_execute_data *call;
19680
92
  uint32_t call_info;
19681
19682
92
  SAVE_OPLINE();
19683
19684
92
  object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19685
19686
92
  if (IS_CV != IS_CONST) {
19687
92
    function_name = EX_VAR(opline->op2.var);
19688
92
  }
19689
19690
92
  if (IS_CV != IS_CONST &&
19691
92
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
19692
0
    do {
19693
0
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
19694
0
        function_name = Z_REFVAL_P(function_name);
19695
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
19696
0
          break;
19697
0
        }
19698
0
      } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
19699
0
        ZVAL_UNDEFINED_OP2();
19700
0
        if (UNEXPECTED(EG(exception) != NULL)) {
19701
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19702
0
          HANDLE_EXCEPTION();
19703
0
        }
19704
0
      }
19705
0
      zend_throw_error(NULL, "Method name must be a string");
19706
19707
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19708
0
      HANDLE_EXCEPTION();
19709
0
    } while (0);
19710
0
  }
19711
19712
92
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
19713
0
    obj = Z_OBJ_P(object);
19714
92
  } else {
19715
92
    do {
19716
92
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19717
92
        obj = Z_OBJ_P(object);
19718
92
      } else {
19719
0
        if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
19720
0
          zend_reference *ref = Z_REF_P(object);
19721
19722
0
          object = &ref->val;
19723
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19724
0
            obj = Z_OBJ_P(object);
19725
0
            if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
19726
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19727
0
                efree_size(ref, sizeof(zend_reference));
19728
0
              } else {
19729
0
                Z_ADDREF_P(object);
19730
0
              }
19731
0
            }
19732
0
            break;
19733
0
          }
19734
0
        }
19735
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
19736
0
          object = ZVAL_UNDEFINED_OP1();
19737
0
          if (UNEXPECTED(EG(exception) != NULL)) {
19738
0
            if (IS_CV != IS_CONST) {
19739
19740
0
            }
19741
0
            HANDLE_EXCEPTION();
19742
0
          }
19743
0
        }
19744
0
        if (IS_CV == IS_CONST) {
19745
0
          function_name = EX_VAR(opline->op2.var);
19746
0
        }
19747
0
        zend_invalid_method_call(object, function_name);
19748
19749
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19750
0
        HANDLE_EXCEPTION();
19751
0
      }
19752
92
    } while (0);
19753
92
  }
19754
19755
92
  called_scope = obj->ce;
19756
19757
92
  if (IS_CV == IS_CONST &&
19758
92
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
19759
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
19760
92
  } else {
19761
92
    zend_object *orig_obj = obj;
19762
19763
92
    if (IS_CV == IS_CONST) {
19764
0
      function_name = EX_VAR(opline->op2.var);
19765
0
    }
19766
19767
    /* First, locate the function. */
19768
92
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
19769
92
    if (UNEXPECTED(fbc == NULL)) {
19770
2
      if (EXPECTED(!EG(exception))) {
19771
2
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
19772
2
      }
19773
19774
2
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
19775
0
        zend_objects_store_del(orig_obj);
19776
0
      }
19777
2
      HANDLE_EXCEPTION();
19778
2
    }
19779
90
    if (IS_CV == IS_CONST &&
19780
90
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
19781
90
        EXPECTED(obj == orig_obj)) {
19782
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
19783
0
    }
19784
90
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
19785
0
      GC_ADDREF(obj); /* For $this pointer */
19786
0
      if (GC_DELREF(orig_obj) == 0) {
19787
0
        zend_objects_store_del(orig_obj);
19788
0
      }
19789
0
    }
19790
90
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
19791
14
      init_func_run_time_cache(&fbc->op_array);
19792
14
    }
19793
90
  }
19794
19795
90
  if (IS_CV != IS_CONST) {
19796
19797
90
  }
19798
19799
90
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19800
90
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
19801
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
19802
0
      zend_objects_store_del(obj);
19803
0
      if (UNEXPECTED(EG(exception))) {
19804
0
        HANDLE_EXCEPTION();
19805
0
      }
19806
0
    }
19807
    /* call static method */
19808
0
    obj = (zend_object*)called_scope;
19809
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
19810
90
  } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
19811
90
    if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
19812
0
      GC_ADDREF(obj); /* For $this pointer */
19813
0
    }
19814
    /* CV may be changed indirectly (e.g. when it's a reference) */
19815
90
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
19816
90
  }
19817
19818
90
  call = zend_vm_stack_push_call_frame(call_info,
19819
90
    fbc, opline->extended_value, obj);
19820
90
  call->prev_execute_data = EX(call);
19821
90
  EX(call) = call;
19822
19823
90
  ZEND_VM_NEXT_OPCODE();
19824
90
}
19825
19826
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19827
0
{
19828
0
  USE_OPLINE
19829
0
  zval *op1, *op2;
19830
0
  double d1, d2;
19831
19832
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19833
0
  op2 = EX_VAR(opline->op2.var);
19834
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
19835
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19836
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
19837
0
case_true:
19838
0
        ZEND_VM_SMART_BRANCH_TRUE();
19839
0
      } else {
19840
0
case_false:
19841
0
        ZEND_VM_SMART_BRANCH_FALSE();
19842
0
      }
19843
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19844
0
      d1 = (double)Z_LVAL_P(op1);
19845
0
      d2 = Z_DVAL_P(op2);
19846
0
      goto case_double;
19847
0
    }
19848
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
19849
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19850
0
      d1 = Z_DVAL_P(op1);
19851
0
      d2 = Z_DVAL_P(op2);
19852
0
case_double:
19853
0
      if (d1 == d2) {
19854
0
        goto case_true;
19855
0
      } else {
19856
0
        goto case_false;
19857
0
      }
19858
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19859
0
      d1 = Z_DVAL_P(op1);
19860
0
      d2 = (double)Z_LVAL_P(op2);
19861
0
      goto case_double;
19862
0
    }
19863
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19864
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19865
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
19866
19867
0
      if (result) {
19868
0
        goto case_true;
19869
0
      } else {
19870
0
        goto case_false;
19871
0
      }
19872
0
    }
19873
0
  }
19874
0
  ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
19875
0
}
19876
19877
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19878
341
{
19879
341
  USE_OPLINE
19880
341
  zval *container;
19881
341
  bool result;
19882
341
  zend_ulong hval;
19883
341
  zval *offset;
19884
19885
341
  SAVE_OPLINE();
19886
341
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19887
341
  offset = EX_VAR(opline->op2.var);
19888
19889
341
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19890
195
    HashTable *ht;
19891
195
    zval *value;
19892
195
    zend_string *str;
19893
19894
195
isset_dim_obj_array:
19895
195
    ht = Z_ARRVAL_P(container);
19896
195
isset_again:
19897
195
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
19898
185
      str = Z_STR_P(offset);
19899
185
      if (IS_CV != IS_CONST) {
19900
185
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
19901
0
          goto num_index_prop;
19902
0
        }
19903
185
      }
19904
185
      value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
19905
185
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
19906
0
      hval = Z_LVAL_P(offset);
19907
0
num_index_prop:
19908
0
      value = zend_hash_index_find(ht, hval);
19909
10
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
19910
0
      offset = Z_REFVAL_P(offset);
19911
0
      goto isset_again;
19912
10
    } else {
19913
10
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
19914
10
      if (UNEXPECTED(EG(exception))) {
19915
0
        result = 0;
19916
0
        goto isset_dim_obj_exit;
19917
0
      }
19918
10
    }
19919
19920
195
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
19921
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
19922
181
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
19923
181
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
19924
19925
181
      if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
19926
        /* avoid exception check */
19927
19928
0
        ZEND_VM_SMART_BRANCH(result, 0);
19929
0
      }
19930
181
    } else {
19931
14
      result = (value == NULL || !i_zend_is_true(value));
19932
14
    }
19933
195
    goto isset_dim_obj_exit;
19934
195
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
19935
0
    container = Z_REFVAL_P(container);
19936
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19937
0
      goto isset_dim_obj_array;
19938
0
    }
19939
0
  }
19940
19941
146
  if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
19942
0
    offset++;
19943
0
  }
19944
146
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
19945
146
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
19946
146
  } else {
19947
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
19948
0
  }
19949
19950
341
isset_dim_obj_exit:
19951
19952
341
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19953
341
  ZEND_VM_SMART_BRANCH(result, 1);
19954
341
}
19955
19956
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19957
55
{
19958
55
  USE_OPLINE
19959
55
  zval *container;
19960
55
  int result;
19961
55
  zval *offset;
19962
55
  zend_string *name, *tmp_name;
19963
19964
55
  SAVE_OPLINE();
19965
55
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19966
55
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19967
19968
55
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19969
55
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19970
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19971
0
      container = Z_REFVAL_P(container);
19972
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
19973
0
        result = (opline->extended_value & ZEND_ISEMPTY);
19974
0
        goto isset_object_finish;
19975
0
      }
19976
0
    } else {
19977
0
      result = (opline->extended_value & ZEND_ISEMPTY);
19978
0
      goto isset_object_finish;
19979
0
    }
19980
0
  }
19981
19982
55
  if (IS_CV == IS_CONST) {
19983
0
    name = Z_STR_P(offset);
19984
55
  } else {
19985
55
    name = zval_try_get_tmp_string(offset, &tmp_name);
19986
55
    if (UNEXPECTED(!name)) {
19987
0
      result = 0;
19988
0
      goto isset_object_finish;
19989
0
    }
19990
55
  }
19991
19992
55
  result =
19993
55
    (opline->extended_value & ZEND_ISEMPTY) ^
19994
55
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
19995
19996
55
  if (IS_CV != IS_CONST) {
19997
55
    zend_tmp_string_release(tmp_name);
19998
55
  }
19999
20000
55
isset_object_finish:
20001
20002
55
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20003
55
  ZEND_VM_SMART_BRANCH(result, 1);
20004
55
}
20005
20006
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20007
0
{
20008
0
  USE_OPLINE
20009
20010
0
  zval *key, *subject;
20011
0
  HashTable *ht;
20012
0
  bool result;
20013
20014
0
  SAVE_OPLINE();
20015
20016
0
  key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
20017
0
  subject = EX_VAR(opline->op2.var);
20018
20019
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
20020
0
array_key_exists_array:
20021
0
    ht = Z_ARRVAL_P(subject);
20022
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
20023
0
  } else {
20024
0
    if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
20025
0
      subject = Z_REFVAL_P(subject);
20026
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
20027
0
        goto array_key_exists_array;
20028
0
      }
20029
0
    }
20030
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
20031
0
    result = 0;
20032
0
  }
20033
20034
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20035
0
  ZEND_VM_SMART_BRANCH(result, 1);
20036
0
}
20037
20038
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20039
6.86k
{
20040
6.86k
  USE_OPLINE
20041
6.86k
  zval *retval_ptr;
20042
6.86k
  zval *return_value;
20043
20044
6.86k
  retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20045
6.86k
  return_value = EX(return_value);
20046
20047
6.86k
  if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
20048
0
    SAVE_OPLINE();
20049
0
    retval_ptr = ZVAL_UNDEFINED_OP1();
20050
0
    if (return_value) {
20051
0
      ZVAL_NULL(return_value);
20052
0
    }
20053
6.86k
  } else if (!return_value) {
20054
202
    if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
20055
202
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
20056
63
        SAVE_OPLINE();
20057
63
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
20058
63
      }
20059
202
    }
20060
6.66k
  } else {
20061
6.66k
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20062
6.66k
      ZVAL_COPY_VALUE(return_value, retval_ptr);
20063
6.66k
      if (IS_TMP_VAR == IS_CONST) {
20064
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
20065
0
          Z_ADDREF_P(return_value);
20066
0
        }
20067
0
      }
20068
6.66k
    } else if (IS_TMP_VAR == IS_CV) {
20069
0
      do {
20070
0
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
20071
0
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
20072
0
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
20073
0
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
20074
0
              ZVAL_COPY_VALUE(return_value, retval_ptr);
20075
0
              if (GC_MAY_LEAK(ref)) {
20076
0
                SAVE_OPLINE();
20077
0
                gc_possible_root(ref);
20078
0
              }
20079
0
              ZVAL_NULL(retval_ptr);
20080
0
              break;
20081
0
            } else {
20082
0
              Z_ADDREF_P(retval_ptr);
20083
0
            }
20084
0
          } else {
20085
0
            retval_ptr = Z_REFVAL_P(retval_ptr);
20086
0
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
20087
0
              Z_ADDREF_P(retval_ptr);
20088
0
            }
20089
0
          }
20090
0
        }
20091
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
20092
0
      } while (0);
20093
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
20094
0
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
20095
0
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
20096
20097
0
        retval_ptr = Z_REFVAL_P(retval_ptr);
20098
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
20099
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20100
0
          efree_size(ref, sizeof(zend_reference));
20101
0
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
20102
0
          Z_ADDREF_P(retval_ptr);
20103
0
        }
20104
0
      } else {
20105
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
20106
0
      }
20107
0
    }
20108
6.66k
  }
20109
20110
20111
20112
6.86k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20113
6.86k
}
20114
20115
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20116
31
{
20117
31
  USE_OPLINE
20118
31
  zval *retval_ptr;
20119
31
  zval *return_value;
20120
20121
31
  SAVE_OPLINE();
20122
20123
31
  return_value = EX(return_value);
20124
20125
31
  do {
20126
31
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) ||
20127
31
        (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
20128
      /* Not supposed to happen, but we'll allow it */
20129
31
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
20130
20131
31
      retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20132
31
      if (!return_value) {
20133
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20134
31
      } else {
20135
31
        if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
20136
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
20137
0
          break;
20138
0
        }
20139
20140
31
        ZVAL_NEW_REF(return_value, retval_ptr);
20141
31
        if (IS_TMP_VAR == IS_CONST) {
20142
0
          Z_TRY_ADDREF_P(retval_ptr);
20143
0
        }
20144
31
      }
20145
31
      break;
20146
31
    }
20147
20148
0
    retval_ptr = zend_get_bad_ptr();
20149
20150
0
    if (IS_TMP_VAR == IS_VAR) {
20151
0
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
20152
0
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
20153
0
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
20154
0
        if (return_value) {
20155
0
          ZVAL_NEW_REF(return_value, retval_ptr);
20156
0
        } else {
20157
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20158
0
        }
20159
0
        break;
20160
0
      }
20161
0
    }
20162
20163
0
    if (return_value) {
20164
0
      if (Z_ISREF_P(retval_ptr)) {
20165
0
        Z_ADDREF_P(retval_ptr);
20166
0
      } else {
20167
0
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
20168
0
      }
20169
0
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
20170
0
    }
20171
20172
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20173
0
  } while (0);
20174
20175
20176
31
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20177
31
}
20178
20179
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20180
30
{
20181
30
  USE_OPLINE
20182
30
  zval *retval;
20183
20184
30
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20185
20186
30
  SAVE_OPLINE();
20187
30
  retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20188
20189
  /* Copy return value into generator->retval */
20190
30
  if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20191
30
    ZVAL_COPY_VALUE(&generator->retval, retval);
20192
30
    if (IS_TMP_VAR == IS_CONST) {
20193
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
20194
0
        Z_ADDREF(generator->retval);
20195
0
      }
20196
0
    }
20197
30
  } else if (IS_TMP_VAR == IS_CV) {
20198
0
    ZVAL_COPY_DEREF(&generator->retval, retval);
20199
0
  } else /* if (IS_TMP_VAR == IS_VAR) */ {
20200
0
    if (UNEXPECTED(Z_ISREF_P(retval))) {
20201
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
20202
20203
0
      retval = Z_REFVAL_P(retval);
20204
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
20205
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20206
0
        efree_size(ref, sizeof(zend_reference));
20207
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
20208
0
        Z_ADDREF_P(retval);
20209
0
      }
20210
0
    } else {
20211
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
20212
0
    }
20213
0
  }
20214
20215
30
  EG(current_execute_data) = EX(prev_execute_data);
20216
20217
  /* Close the generator to free up resources */
20218
30
  zend_generator_close(generator, 1);
20219
20220
  /* Pass execution back to handling code */
20221
30
  ZEND_VM_RETURN();
20222
30
}
20223
20224
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20225
12
{
20226
12
  USE_OPLINE
20227
12
  zval *arg, *param;
20228
20229
12
  SAVE_OPLINE();
20230
20231
12
  arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20232
12
  param = ZEND_CALL_VAR(EX(call), opline->result.var);
20233
12
  if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
20234
5
    zend_param_must_be_ref(EX(call)->func, opline->op2.num);
20235
5
    Z_TRY_ADDREF_P(arg);
20236
5
    ZVAL_NEW_REF(param, arg);
20237
7
  } else {
20238
7
    ZVAL_COPY(param, arg);
20239
7
  }
20240
20241
12
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20242
12
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20243
12
}
20244
20245
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20246
406
{
20247
406
  USE_OPLINE
20248
406
  zval *expr;
20249
406
  zval *result = EX_VAR(opline->result.var);
20250
20251
406
  SAVE_OPLINE();
20252
406
  expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20253
20254
406
  switch (opline->extended_value) {
20255
124
    case IS_LONG:
20256
124
      ZVAL_LONG(result, zval_get_long(expr));
20257
124
      break;
20258
27
    case IS_DOUBLE:
20259
27
      ZVAL_DOUBLE(result, zval_get_double(expr));
20260
27
      break;
20261
208
    case IS_STRING:
20262
208
      ZVAL_STR(result, zval_get_string(expr));
20263
208
      break;
20264
47
    default:
20265
47
      ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
20266
47
      if (IS_TMP_VAR & (IS_VAR|IS_CV)) {
20267
0
        ZVAL_DEREF(expr);
20268
0
      }
20269
      /* If value is already of correct type, return it directly */
20270
47
      if (Z_TYPE_P(expr) == opline->extended_value) {
20271
5
        ZVAL_COPY_VALUE(result, expr);
20272
5
        if (IS_TMP_VAR == IS_CONST) {
20273
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20274
5
        } else if (IS_TMP_VAR != IS_TMP_VAR) {
20275
0
          if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20276
0
        }
20277
20278
5
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20279
5
      }
20280
20281
42
      if (opline->extended_value == IS_ARRAY) {
20282
37
        zend_cast_zval_to_array(result, expr, IS_TMP_VAR);
20283
37
      } else {
20284
5
        ZEND_ASSERT(opline->extended_value == IS_OBJECT);
20285
5
        zend_cast_zval_to_object(result, expr, IS_TMP_VAR);
20286
5
      }
20287
406
  }
20288
20289
401
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20290
401
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20291
401
}
20292
20293
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20294
457
{
20295
457
  USE_OPLINE
20296
457
  zval *array_ptr, *result;
20297
20298
457
  SAVE_OPLINE();
20299
20300
457
  array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20301
457
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
20302
176
    result = EX_VAR(opline->result.var);
20303
176
    ZVAL_COPY_VALUE(result, array_ptr);
20304
176
    if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
20305
0
      Z_ADDREF_P(array_ptr);
20306
0
    }
20307
176
    Z_FE_POS_P(result) = 0;
20308
20309
176
    ZEND_VM_NEXT_OPCODE();
20310
281
  } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
20311
186
    zend_object *zobj = Z_OBJ_P(array_ptr);
20312
186
    if (!zobj->ce->get_iterator) {
20313
32
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
20314
0
        zobj = zend_lazy_object_init(zobj);
20315
0
        if (UNEXPECTED(EG(exception))) {
20316
0
          UNDEF_RESULT();
20317
20318
0
          HANDLE_EXCEPTION();
20319
0
        }
20320
0
      }
20321
32
      HashTable *properties = zobj->properties;
20322
32
      if (properties) {
20323
5
        if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
20324
0
          if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
20325
0
            GC_DELREF(properties);
20326
0
          }
20327
0
          properties = zobj->properties = zend_array_dup(properties);
20328
0
        }
20329
27
      } else {
20330
27
        properties = zobj->handlers->get_properties(zobj);
20331
27
      }
20332
20333
32
      result = EX_VAR(opline->result.var);
20334
32
      ZVAL_COPY_VALUE(result, array_ptr);
20335
32
      if (IS_TMP_VAR != IS_TMP_VAR) {
20336
0
        Z_ADDREF_P(array_ptr);
20337
0
      }
20338
20339
32
      if (zend_hash_num_elements(properties) == 0) {
20340
10
        Z_FE_ITER_P(result) = (uint32_t) -1;
20341
20342
10
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20343
10
      }
20344
20345
22
      Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
20346
20347
22
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20348
154
    } else {
20349
154
      bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
20350
20351
154
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20352
154
      if (UNEXPECTED(EG(exception))) {
20353
60
        HANDLE_EXCEPTION();
20354
94
      } else if (is_empty) {
20355
10
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20356
84
      } else {
20357
84
        ZEND_VM_NEXT_OPCODE();
20358
84
      }
20359
154
    }
20360
186
  } else {
20361
95
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
20362
95
    ZVAL_UNDEF(EX_VAR(opline->result.var));
20363
95
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
20364
95
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20365
95
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20366
95
  }
20367
457
}
20368
20369
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20370
32
{
20371
32
  USE_OPLINE
20372
32
  zval *array_ptr, *array_ref;
20373
20374
32
  SAVE_OPLINE();
20375
20376
32
  if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20377
0
    array_ref = array_ptr = zend_get_bad_ptr();
20378
0
    if (Z_ISREF_P(array_ref)) {
20379
0
      array_ptr = Z_REFVAL_P(array_ref);
20380
0
    }
20381
32
  } else {
20382
32
    array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20383
32
  }
20384
20385
32
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
20386
22
    if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20387
0
      if (array_ptr == array_ref) {
20388
0
        ZVAL_NEW_REF(array_ref, array_ref);
20389
0
        array_ptr = Z_REFVAL_P(array_ref);
20390
0
      }
20391
0
      Z_ADDREF_P(array_ref);
20392
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
20393
22
    } else {
20394
22
      array_ref = EX_VAR(opline->result.var);
20395
22
      ZVAL_NEW_REF(array_ref, array_ptr);
20396
22
      array_ptr = Z_REFVAL_P(array_ref);
20397
22
    }
20398
22
    if (IS_TMP_VAR == IS_CONST) {
20399
0
      ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
20400
22
    } else {
20401
22
      SEPARATE_ARRAY(array_ptr);
20402
22
    }
20403
22
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
20404
20405
22
    ZEND_VM_NEXT_OPCODE();
20406
22
  } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
20407
0
    if (!Z_OBJCE_P(array_ptr)->get_iterator) {
20408
0
      zend_object *zobj = Z_OBJ_P(array_ptr);
20409
0
      HashTable *properties;
20410
0
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
20411
0
        zobj = zend_lazy_object_init(zobj);
20412
0
        if (UNEXPECTED(EG(exception))) {
20413
0
          UNDEF_RESULT();
20414
20415
0
          HANDLE_EXCEPTION();
20416
0
        }
20417
0
      }
20418
0
      if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20419
0
        if (array_ptr == array_ref) {
20420
0
          ZVAL_NEW_REF(array_ref, array_ref);
20421
0
          array_ptr = Z_REFVAL_P(array_ref);
20422
0
        }
20423
0
        Z_ADDREF_P(array_ref);
20424
0
        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
20425
0
      } else {
20426
0
        array_ptr = EX_VAR(opline->result.var);
20427
0
        ZVAL_COPY_VALUE(array_ptr, array_ref);
20428
0
      }
20429
0
      if (Z_OBJ_P(array_ptr)->properties
20430
0
       && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
20431
0
        if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
20432
0
          GC_DELREF(Z_OBJ_P(array_ptr)->properties);
20433
0
        }
20434
0
        Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
20435
0
      }
20436
20437
0
      properties = Z_OBJPROP_P(array_ptr);
20438
0
      if (zend_hash_num_elements(properties) == 0) {
20439
0
        Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
20440
20441
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20442
0
      }
20443
20444
0
      Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
20445
20446
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20447
0
    } else {
20448
0
      bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
20449
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20450
0
      if (UNEXPECTED(EG(exception))) {
20451
0
        HANDLE_EXCEPTION();
20452
0
      } else if (is_empty) {
20453
0
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20454
0
      } else {
20455
0
        ZEND_VM_NEXT_OPCODE();
20456
0
      }
20457
0
    }
20458
10
  } else {
20459
10
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
20460
10
    ZVAL_UNDEF(EX_VAR(opline->result.var));
20461
10
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
20462
10
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20463
10
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20464
10
  }
20465
32
}
20466
20467
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20468
21.9k
{
20469
21.9k
  USE_OPLINE
20470
20471
21.9k
  if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))
20472
21.9k
      && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) {
20473
138
    EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
20474
138
  }
20475
21.9k
  ZEND_VM_NEXT_OPCODE();
20476
21.9k
}
20477
20478
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20479
1.72k
{
20480
1.72k
  USE_OPLINE
20481
1.72k
  zval *value;
20482
1.72k
  zend_reference *ref = NULL;
20483
1.72k
  bool ret;
20484
20485
1.72k
  SAVE_OPLINE();
20486
1.72k
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20487
20488
1.72k
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) {
20489
0
    if (IS_TMP_VAR == IS_VAR) {
20490
0
      ref = Z_REF_P(value);
20491
0
    }
20492
0
    value = Z_REFVAL_P(value);
20493
0
  }
20494
20495
1.72k
  ret = i_zend_is_true(value);
20496
20497
1.72k
  if (UNEXPECTED(EG(exception))) {
20498
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20499
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
20500
0
    HANDLE_EXCEPTION();
20501
0
  }
20502
20503
1.72k
  if (ret) {
20504
993
    zval *result = EX_VAR(opline->result.var);
20505
20506
993
    ZVAL_COPY_VALUE(result, value);
20507
993
    if (IS_TMP_VAR == IS_CONST) {
20508
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20509
993
    } else if (IS_TMP_VAR == IS_CV) {
20510
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20511
993
    } else if (IS_TMP_VAR == IS_VAR && ref) {
20512
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20513
0
        efree_size(ref, sizeof(zend_reference));
20514
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
20515
0
        Z_ADDREF_P(result);
20516
0
      }
20517
0
    }
20518
993
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20519
993
  }
20520
20521
732
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20522
732
  ZEND_VM_NEXT_OPCODE();
20523
732
}
20524
20525
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20526
1.51k
{
20527
1.51k
  USE_OPLINE
20528
1.51k
  zval *value;
20529
1.51k
  zend_reference *ref = NULL;
20530
20531
1.51k
  SAVE_OPLINE();
20532
1.51k
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20533
20534
1.51k
  if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20535
0
    if (IS_TMP_VAR & IS_VAR) {
20536
0
      ref = Z_REF_P(value);
20537
0
    }
20538
0
    value = Z_REFVAL_P(value);
20539
0
  }
20540
20541
1.51k
  if (Z_TYPE_P(value) > IS_NULL) {
20542
640
    zval *result = EX_VAR(opline->result.var);
20543
640
    ZVAL_COPY_VALUE(result, value);
20544
640
    if (IS_TMP_VAR == IS_CONST) {
20545
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20546
640
    } else if (IS_TMP_VAR == IS_CV) {
20547
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20548
640
    } else if ((IS_TMP_VAR & IS_VAR) && ref) {
20549
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20550
0
        efree_size(ref, sizeof(zend_reference));
20551
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
20552
0
        Z_ADDREF_P(result);
20553
0
      }
20554
0
    }
20555
640
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20556
640
  }
20557
20558
878
  if ((IS_TMP_VAR & IS_VAR) && ref) {
20559
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20560
0
      efree_size(ref, sizeof(zend_reference));
20561
0
    }
20562
0
  }
20563
878
  ZEND_VM_NEXT_OPCODE();
20564
878
}
20565
20566
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20567
210
{
20568
210
  USE_OPLINE
20569
210
  zval *val, *result;
20570
20571
210
  val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20572
20573
210
  if (Z_TYPE_P(val) > IS_NULL) {
20574
27
    do {
20575
27
      if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
20576
0
        val = Z_REFVAL_P(val);
20577
0
        if (Z_TYPE_P(val) <= IS_NULL) {
20578
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20579
0
          break;
20580
0
        }
20581
0
      }
20582
27
      ZEND_VM_NEXT_OPCODE();
20583
27
    } while (0);
20584
27
  }
20585
20586
183
  result = EX_VAR(opline->result.var);
20587
183
  uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
20588
183
  if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
20589
183
    ZVAL_NULL(result);
20590
183
    if (IS_TMP_VAR == IS_CV
20591
183
      && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
20592
183
      && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
20593
183
    ) {
20594
0
      SAVE_OPLINE();
20595
0
      ZVAL_UNDEFINED_OP1();
20596
0
      if (UNEXPECTED(EG(exception) != NULL)) {
20597
0
        HANDLE_EXCEPTION();
20598
0
      }
20599
0
    }
20600
183
  } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
20601
0
    ZVAL_FALSE(result);
20602
0
  } else {
20603
0
    ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
20604
0
    ZVAL_TRUE(result);
20605
0
  }
20606
20607
183
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20608
183
}
20609
20610
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20611
420
{
20612
420
  USE_OPLINE
20613
420
  zval *value;
20614
420
  zval *result = EX_VAR(opline->result.var);
20615
20616
420
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20617
420
  if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
20618
0
    SAVE_OPLINE();
20619
0
    ZVAL_UNDEFINED_OP1();
20620
0
    ZVAL_NULL(result);
20621
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20622
0
  }
20623
20624
420
  if (IS_TMP_VAR == IS_CV) {
20625
0
    ZVAL_COPY_DEREF(result, value);
20626
420
  } else if (IS_TMP_VAR == IS_VAR) {
20627
0
    if (UNEXPECTED(Z_ISREF_P(value))) {
20628
0
      ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
20629
0
      if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
20630
0
        efree_size(Z_REF_P(value), sizeof(zend_reference));
20631
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
20632
0
        Z_ADDREF_P(result);
20633
0
      }
20634
0
    } else {
20635
0
      ZVAL_COPY_VALUE(result, value);
20636
0
    }
20637
420
  } else {
20638
420
    ZVAL_COPY_VALUE(result, value);
20639
420
    if (IS_TMP_VAR == IS_CONST) {
20640
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
20641
0
        Z_ADDREF_P(result);
20642
0
      }
20643
0
    }
20644
420
  }
20645
420
  ZEND_VM_NEXT_OPCODE();
20646
420
}
20647
20648
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20649
1.05k
{
20650
1.05k
  USE_OPLINE
20651
1.05k
  zval *op1, *op2;
20652
1.05k
  bool result;
20653
20654
1.05k
  SAVE_OPLINE();
20655
1.05k
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20656
1.05k
  op2 = RT_CONSTANT(opline, opline->op2);
20657
1.05k
  result = fast_is_identical_function(op1, op2);
20658
1.05k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20659
20660
1.05k
  ZEND_VM_SMART_BRANCH(result, 1);
20661
1.05k
}
20662
20663
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20664
0
{
20665
0
  USE_OPLINE
20666
0
  zval *op1, *op2;
20667
0
  bool result;
20668
20669
0
  SAVE_OPLINE();
20670
0
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20671
0
  op2 = RT_CONSTANT(opline, opline->op2);
20672
0
  result = fast_is_identical_function(op1, op2);
20673
20674
0
  ZEND_VM_SMART_BRANCH(result, 1);
20675
0
}
20676
20677
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20678
99
{
20679
99
  USE_OPLINE
20680
99
  zval *op1, *op2;
20681
99
  bool result;
20682
20683
99
  SAVE_OPLINE();
20684
99
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20685
99
  op2 = RT_CONSTANT(opline, opline->op2);
20686
99
  result = fast_is_not_identical_function(op1, op2);
20687
99
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20688
20689
99
  ZEND_VM_SMART_BRANCH(result, 1);
20690
99
}
20691
20692
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20693
10
{
20694
#if 0
20695
  USE_OPLINE
20696
#endif
20697
20698
10
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20699
10
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20700
10
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20701
10
    }
20702
10
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20703
10
  } else {
20704
0
    if (IS_CONST == IS_UNUSED) {
20705
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20706
0
    }
20707
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20708
0
  }
20709
10
}
20710
20711
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20712
0
{
20713
#if 0
20714
  USE_OPLINE
20715
#endif
20716
20717
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20718
    /* Behave like FETCH_OBJ_W */
20719
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20720
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20721
0
    }
20722
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20723
0
  } else {
20724
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20725
0
  }
20726
0
}
20727
20728
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20729
428k
{
20730
428k
  USE_OPLINE
20731
428k
  zend_string **rope;
20732
428k
  zval *var;
20733
20734
  /* op1 and result are the same */
20735
428k
  rope = (zend_string**)EX_VAR(opline->op1.var);
20736
428k
  if (IS_CONST == IS_CONST) {
20737
428k
    var = RT_CONSTANT(opline, opline->op2);
20738
428k
    rope[opline->extended_value] = Z_STR_P(var);
20739
428k
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20740
3
      Z_ADDREF_P(var);
20741
3
    }
20742
428k
  } else {
20743
0
    var = RT_CONSTANT(opline, opline->op2);
20744
0
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20745
0
      if (IS_CONST == IS_CV) {
20746
0
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20747
0
      } else {
20748
0
        rope[opline->extended_value] = Z_STR_P(var);
20749
0
      }
20750
0
    } else {
20751
0
      SAVE_OPLINE();
20752
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20753
0
        ZVAL_UNDEFINED_OP2();
20754
0
      }
20755
0
      rope[opline->extended_value] = zval_get_string_func(var);
20756
20757
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20758
0
    }
20759
0
  }
20760
428k
  ZEND_VM_NEXT_OPCODE();
20761
428k
}
20762
20763
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20764
316k
{
20765
316k
  USE_OPLINE
20766
316k
  zend_string **rope;
20767
316k
  zval *var, *ret;
20768
316k
  uint32_t i;
20769
20770
316k
  rope = (zend_string**)EX_VAR(opline->op1.var);
20771
316k
  if (IS_CONST == IS_CONST) {
20772
316k
    var = RT_CONSTANT(opline, opline->op2);
20773
316k
    rope[opline->extended_value] = Z_STR_P(var);
20774
316k
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20775
5
      Z_ADDREF_P(var);
20776
5
    }
20777
316k
  } else {
20778
0
    var = RT_CONSTANT(opline, opline->op2);
20779
0
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20780
0
      if (IS_CONST == IS_CV) {
20781
0
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20782
0
      } else {
20783
0
        rope[opline->extended_value] = Z_STR_P(var);
20784
0
      }
20785
0
    } else {
20786
0
      SAVE_OPLINE();
20787
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20788
0
        ZVAL_UNDEFINED_OP2();
20789
0
      }
20790
0
      rope[opline->extended_value] = zval_get_string_func(var);
20791
20792
0
      if (UNEXPECTED(EG(exception))) {
20793
0
        for (i = 0; i <= opline->extended_value; i++) {
20794
0
          zend_string_release_ex(rope[i], 0);
20795
0
        }
20796
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
20797
0
        HANDLE_EXCEPTION();
20798
0
      }
20799
0
    }
20800
0
  }
20801
20802
316k
  size_t len = 0;
20803
316k
  uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
20804
1.99M
  for (i = 0; i <= opline->extended_value; i++) {
20805
1.68M
    flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
20806
1.68M
    len += ZSTR_LEN(rope[i]);
20807
1.68M
  }
20808
316k
  ret = EX_VAR(opline->result.var);
20809
316k
  ZVAL_STR(ret, zend_string_alloc(len, 0));
20810
316k
  GC_ADD_FLAGS(Z_STR_P(ret), flags);
20811
20812
316k
  char *target = Z_STRVAL_P(ret);
20813
1.99M
  for (i = 0; i <= opline->extended_value; i++) {
20814
1.67M
    memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
20815
1.67M
    target += ZSTR_LEN(rope[i]);
20816
1.67M
    zend_string_release_ex(rope[i], 0);
20817
1.67M
  }
20818
316k
  *target = '\0';
20819
20820
316k
  ZEND_VM_NEXT_OPCODE();
20821
316k
}
20822
20823
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20824
7
{
20825
7
  USE_OPLINE
20826
7
  zval *value, *arg;
20827
7
  uint32_t arg_num;
20828
20829
7
  if (IS_CONST == IS_CONST) {
20830
7
    SAVE_OPLINE();
20831
7
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
20832
7
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
20833
7
    if (UNEXPECTED(!arg)) {
20834
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20835
0
      HANDLE_EXCEPTION();
20836
0
    }
20837
7
  } else {
20838
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
20839
0
    arg_num = opline->op2.num;
20840
0
  }
20841
20842
7
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
20843
7
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20844
0
      goto send_val_by_ref;
20845
0
    }
20846
7
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20847
0
send_val_by_ref:
20848
0
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
20849
0
  }
20850
7
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20851
7
  ZVAL_COPY_VALUE(arg, value);
20852
7
  if (IS_TMP_VAR == IS_CONST) {
20853
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
20854
0
      Z_ADDREF_P(arg);
20855
0
    }
20856
0
  }
20857
7
  ZEND_VM_NEXT_OPCODE();
20858
7
}
20859
20860
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20861
315
{
20862
315
  USE_OPLINE
20863
315
  zval *expr_ptr, new_expr;
20864
20865
315
  SAVE_OPLINE();
20866
315
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
20867
315
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
20868
0
    expr_ptr = zend_get_bad_ptr();
20869
0
    if (Z_ISREF_P(expr_ptr)) {
20870
0
      Z_ADDREF_P(expr_ptr);
20871
0
    } else {
20872
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
20873
0
    }
20874
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20875
315
  } else {
20876
315
    expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20877
315
    if (IS_TMP_VAR == IS_TMP_VAR) {
20878
      /* pass */
20879
315
    } else if (IS_TMP_VAR == IS_CONST) {
20880
0
      Z_TRY_ADDREF_P(expr_ptr);
20881
0
    } else if (IS_TMP_VAR == IS_CV) {
20882
0
      ZVAL_DEREF(expr_ptr);
20883
0
      Z_TRY_ADDREF_P(expr_ptr);
20884
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
20885
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
20886
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
20887
20888
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
20889
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20890
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
20891
0
          expr_ptr = &new_expr;
20892
0
          efree_size(ref, sizeof(zend_reference));
20893
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
20894
0
          Z_ADDREF_P(expr_ptr);
20895
0
        }
20896
0
      }
20897
0
    }
20898
315
  }
20899
20900
315
  if (IS_CONST != IS_UNUSED) {
20901
315
    zval *offset = RT_CONSTANT(opline, opline->op2);
20902
315
    zend_string *str;
20903
315
    zend_ulong hval;
20904
20905
315
add_again:
20906
315
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
20907
287
      str = Z_STR_P(offset);
20908
287
      if (IS_CONST != IS_CONST) {
20909
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
20910
0
          goto num_index;
20911
0
        }
20912
0
      }
20913
287
str_index:
20914
287
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
20915
287
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
20916
28
      hval = Z_LVAL_P(offset);
20917
28
num_index:
20918
28
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
20919
28
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
20920
0
      offset = Z_REFVAL_P(offset);
20921
0
      goto add_again;
20922
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
20923
0
      str = ZSTR_EMPTY_ALLOC();
20924
0
      goto str_index;
20925
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
20926
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
20927
0
      goto num_index;
20928
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
20929
0
      hval = 0;
20930
0
      goto num_index;
20931
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
20932
0
      hval = 1;
20933
0
      goto num_index;
20934
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
20935
0
      zend_use_resource_as_offset(offset);
20936
0
      hval = Z_RES_HANDLE_P(offset);
20937
0
      goto num_index;
20938
0
    } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
20939
0
      ZVAL_UNDEFINED_OP2();
20940
0
      str = ZSTR_EMPTY_ALLOC();
20941
0
      goto str_index;
20942
0
    } else {
20943
0
      zend_illegal_array_offset_access(offset);
20944
0
      zval_ptr_dtor_nogc(expr_ptr);
20945
0
    }
20946
20947
315
  } else {
20948
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
20949
0
      zend_cannot_add_element();
20950
0
      zval_ptr_dtor_nogc(expr_ptr);
20951
0
    }
20952
0
  }
20953
315
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20954
315
}
20955
20956
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20957
85
{
20958
85
  zval *array;
20959
85
  uint32_t size;
20960
85
  USE_OPLINE
20961
20962
85
  SAVE_OPLINE();
20963
85
  array = EX_VAR(opline->result.var);
20964
85
  if (IS_TMP_VAR != IS_UNUSED) {
20965
85
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
20966
85
    ZVAL_ARR(array, zend_new_array(size));
20967
    /* Explicitly initialize array as not-packed if flag is set */
20968
85
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
20969
67
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
20970
67
    }
20971
85
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20972
85
  } else {
20973
0
    ZVAL_ARR(array, zend_new_array(0));
20974
0
    ZEND_VM_NEXT_OPCODE();
20975
0
  }
20976
85
}
20977
20978
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20979
0
{
20980
0
  USE_OPLINE
20981
20982
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20983
20984
0
  SAVE_OPLINE();
20985
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
20986
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20987
0
  }
20988
20989
  /* Destroy the previously yielded value */
20990
0
  zval_ptr_dtor(&generator->value);
20991
20992
  /* Destroy the previously yielded key */
20993
0
  zval_ptr_dtor(&generator->key);
20994
20995
  /* Set the new yielded value */
20996
0
  if (IS_TMP_VAR != IS_UNUSED) {
20997
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20998
      /* Constants and temporary variables aren't yieldable by reference,
20999
       * but we still allow them with a notice. */
21000
0
      if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21001
0
        zval *value;
21002
21003
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21004
21005
0
        value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21006
0
        ZVAL_COPY_VALUE(&generator->value, value);
21007
0
        if (IS_TMP_VAR == IS_CONST) {
21008
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21009
0
            Z_ADDREF(generator->value);
21010
0
          }
21011
0
        }
21012
0
      } else {
21013
0
        zval *value_ptr = zend_get_bad_ptr();
21014
21015
        /* If a function call result is yielded and the function did
21016
         * not return by reference we throw a notice. */
21017
0
        do {
21018
0
          if (IS_TMP_VAR == IS_VAR) {
21019
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21020
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
21021
0
             && !Z_ISREF_P(value_ptr)) {
21022
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21023
0
              ZVAL_COPY(&generator->value, value_ptr);
21024
0
              break;
21025
0
            }
21026
0
          }
21027
0
          if (Z_ISREF_P(value_ptr)) {
21028
0
            Z_ADDREF_P(value_ptr);
21029
0
          } else {
21030
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
21031
0
          }
21032
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21033
0
        } while (0);
21034
21035
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21036
0
      }
21037
0
    } else {
21038
0
      zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21039
21040
      /* Consts, temporary variables and references need copying */
21041
0
      if (IS_TMP_VAR == IS_CONST) {
21042
0
        ZVAL_COPY_VALUE(&generator->value, value);
21043
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21044
0
          Z_ADDREF(generator->value);
21045
0
        }
21046
0
      } else if (IS_TMP_VAR == IS_TMP_VAR) {
21047
0
        ZVAL_COPY_VALUE(&generator->value, value);
21048
0
      } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21049
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21050
21051
0
      } else {
21052
0
        ZVAL_COPY_VALUE(&generator->value, value);
21053
0
        if (IS_TMP_VAR == IS_CV) {
21054
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21055
0
        }
21056
0
      }
21057
0
    }
21058
0
  } else {
21059
    /* If no value was specified yield null */
21060
0
    ZVAL_NULL(&generator->value);
21061
0
  }
21062
21063
  /* Set the new yielded key */
21064
0
  if (IS_CONST != IS_UNUSED) {
21065
0
    zval *key = RT_CONSTANT(opline, opline->op2);
21066
0
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21067
0
      key = Z_REFVAL_P(key);
21068
0
    }
21069
0
    ZVAL_COPY(&generator->key, key);
21070
21071
0
    if (Z_TYPE(generator->key) == IS_LONG
21072
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
21073
0
    ) {
21074
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
21075
0
    }
21076
0
  } else {
21077
    /* If no key was specified we use auto-increment keys */
21078
0
    generator->largest_used_integer_key++;
21079
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21080
0
  }
21081
21082
0
  if (RETURN_VALUE_USED(opline)) {
21083
    /* If the return value of yield is used set the send
21084
     * target and initialize it to NULL */
21085
0
    generator->send_target = EX_VAR(opline->result.var);
21086
0
    ZVAL_NULL(generator->send_target);
21087
0
  } else {
21088
0
    generator->send_target = NULL;
21089
0
  }
21090
21091
  /* The GOTO VM uses a local opline variable. We need to set the opline
21092
   * variable in execute_data so we don't resume at an old position. */
21093
0
  SAVE_OPLINE();
21094
21095
0
  ZEND_VM_RETURN();
21096
0
}
21097
21098
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21099
0
{
21100
0
  USE_OPLINE
21101
0
  zval *op1;
21102
0
  HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
21103
0
  zval *result;
21104
21105
0
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21106
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
21107
0
    result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST);
21108
0
    if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) {
21109
0
      zval_ptr_dtor_str(op1);
21110
0
    }
21111
0
    ZEND_VM_SMART_BRANCH(result, 0);
21112
0
  }
21113
21114
0
  if (opline->extended_value) {
21115
0
    if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
21116
0
      result = zend_hash_index_find(ht, Z_LVAL_P(op1));
21117
0
      ZEND_VM_SMART_BRANCH(result, 0);
21118
0
    }
21119
0
    SAVE_OPLINE();
21120
0
    if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
21121
0
      op1 = Z_REFVAL_P(op1);
21122
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
21123
0
        result = zend_hash_find(ht, Z_STR_P(op1));
21124
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21125
0
        ZEND_VM_SMART_BRANCH(result, 0);
21126
0
      } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
21127
0
        result = zend_hash_index_find(ht, Z_LVAL_P(op1));
21128
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21129
0
        ZEND_VM_SMART_BRANCH(result, 0);
21130
0
      }
21131
0
    } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
21132
0
      ZVAL_UNDEFINED_OP1();
21133
0
    }
21134
0
  } else if (Z_TYPE_P(op1) <= IS_FALSE) {
21135
0
    if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
21136
0
      SAVE_OPLINE();
21137
0
      ZVAL_UNDEFINED_OP1();
21138
0
      if (UNEXPECTED(EG(exception) != NULL)) {
21139
0
        HANDLE_EXCEPTION();
21140
0
      }
21141
0
    }
21142
0
    result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
21143
0
    ZEND_VM_SMART_BRANCH(result, 0);
21144
0
  } else {
21145
0
    zend_string *key;
21146
0
    zval key_tmp;
21147
21148
0
    if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
21149
0
      op1 = Z_REFVAL_P(op1);
21150
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
21151
0
        result = zend_hash_find(ht, Z_STR_P(op1));
21152
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21153
0
        ZEND_VM_SMART_BRANCH(result, 0);
21154
0
      }
21155
0
    }
21156
21157
0
    SAVE_OPLINE();
21158
0
    ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
21159
0
      ZVAL_STR(&key_tmp, key);
21160
0
      if (zend_compare(op1, &key_tmp) == 0) {
21161
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21162
0
        ZEND_VM_SMART_BRANCH(1, 1);
21163
0
      }
21164
0
    } ZEND_HASH_FOREACH_END();
21165
0
  }
21166
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21167
0
  ZEND_VM_SMART_BRANCH(0, 1);
21168
0
}
21169
21170
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21171
0
{
21172
#if 0
21173
  USE_OPLINE
21174
#endif
21175
21176
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21177
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21178
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21179
0
    }
21180
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21181
0
  } else {
21182
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
21183
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21184
0
    }
21185
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21186
0
  }
21187
0
}
21188
21189
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21190
0
{
21191
#if 0
21192
  USE_OPLINE
21193
#endif
21194
21195
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21196
    /* Behave like FETCH_OBJ_W */
21197
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21198
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21199
0
    }
21200
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21201
0
  } else {
21202
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21203
0
  }
21204
0
}
21205
21206
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21207
91.6k
{
21208
91.6k
  USE_OPLINE
21209
91.6k
  zend_string **rope;
21210
91.6k
  zval *var;
21211
21212
  /* op1 and result are the same */
21213
91.6k
  rope = (zend_string**)EX_VAR(opline->op1.var);
21214
91.6k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
21215
0
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21216
0
    rope[opline->extended_value] = Z_STR_P(var);
21217
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21218
0
      Z_ADDREF_P(var);
21219
0
    }
21220
91.6k
  } else {
21221
91.6k
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21222
91.6k
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21223
191
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
21224
0
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21225
191
      } else {
21226
191
        rope[opline->extended_value] = Z_STR_P(var);
21227
191
      }
21228
91.4k
    } else {
21229
91.4k
      SAVE_OPLINE();
21230
91.4k
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21231
0
        ZVAL_UNDEFINED_OP2();
21232
0
      }
21233
91.4k
      rope[opline->extended_value] = zval_get_string_func(var);
21234
91.4k
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21235
91.4k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21236
91.4k
    }
21237
91.6k
  }
21238
191
  ZEND_VM_NEXT_OPCODE();
21239
191
}
21240
21241
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21242
427
{
21243
427
  USE_OPLINE
21244
427
  zend_string **rope;
21245
427
  zval *var, *ret;
21246
427
  uint32_t i;
21247
21248
427
  rope = (zend_string**)EX_VAR(opline->op1.var);
21249
427
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
21250
0
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21251
0
    rope[opline->extended_value] = Z_STR_P(var);
21252
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21253
0
      Z_ADDREF_P(var);
21254
0
    }
21255
427
  } else {
21256
427
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21257
427
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21258
16
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
21259
0
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21260
16
      } else {
21261
16
        rope[opline->extended_value] = Z_STR_P(var);
21262
16
      }
21263
411
    } else {
21264
411
      SAVE_OPLINE();
21265
411
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21266
0
        ZVAL_UNDEFINED_OP2();
21267
0
      }
21268
411
      rope[opline->extended_value] = zval_get_string_func(var);
21269
411
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21270
411
      if (UNEXPECTED(EG(exception))) {
21271
0
        for (i = 0; i <= opline->extended_value; i++) {
21272
0
          zend_string_release_ex(rope[i], 0);
21273
0
        }
21274
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
21275
0
        HANDLE_EXCEPTION();
21276
0
      }
21277
411
    }
21278
427
  }
21279
21280
427
  size_t len = 0;
21281
427
  uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
21282
19.5k
  for (i = 0; i <= opline->extended_value; i++) {
21283
19.0k
    flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
21284
19.0k
    len += ZSTR_LEN(rope[i]);
21285
19.0k
  }
21286
427
  ret = EX_VAR(opline->result.var);
21287
427
  ZVAL_STR(ret, zend_string_alloc(len, 0));
21288
427
  GC_ADD_FLAGS(Z_STR_P(ret), flags);
21289
21290
427
  char *target = Z_STRVAL_P(ret);
21291
19.5k
  for (i = 0; i <= opline->extended_value; i++) {
21292
19.0k
    memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
21293
19.0k
    target += ZSTR_LEN(rope[i]);
21294
19.0k
    zend_string_release_ex(rope[i], 0);
21295
19.0k
  }
21296
427
  *target = '\0';
21297
21298
427
  ZEND_VM_NEXT_OPCODE();
21299
427
}
21300
21301
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21302
6
{
21303
6
  USE_OPLINE
21304
6
  zval *expr_ptr, new_expr;
21305
21306
6
  SAVE_OPLINE();
21307
6
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21308
6
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21309
0
    expr_ptr = zend_get_bad_ptr();
21310
0
    if (Z_ISREF_P(expr_ptr)) {
21311
0
      Z_ADDREF_P(expr_ptr);
21312
0
    } else {
21313
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
21314
0
    }
21315
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21316
6
  } else {
21317
6
    expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21318
6
    if (IS_TMP_VAR == IS_TMP_VAR) {
21319
      /* pass */
21320
6
    } else if (IS_TMP_VAR == IS_CONST) {
21321
0
      Z_TRY_ADDREF_P(expr_ptr);
21322
0
    } else if (IS_TMP_VAR == IS_CV) {
21323
0
      ZVAL_DEREF(expr_ptr);
21324
0
      Z_TRY_ADDREF_P(expr_ptr);
21325
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
21326
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21327
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21328
21329
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
21330
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21331
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21332
0
          expr_ptr = &new_expr;
21333
0
          efree_size(ref, sizeof(zend_reference));
21334
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21335
0
          Z_ADDREF_P(expr_ptr);
21336
0
        }
21337
0
      }
21338
0
    }
21339
6
  }
21340
21341
6
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
21342
6
    zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21343
6
    zend_string *str;
21344
6
    zend_ulong hval;
21345
21346
6
add_again:
21347
6
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21348
6
      str = Z_STR_P(offset);
21349
6
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
21350
6
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
21351
0
          goto num_index;
21352
0
        }
21353
6
      }
21354
6
str_index:
21355
6
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21356
6
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21357
0
      hval = Z_LVAL_P(offset);
21358
0
num_index:
21359
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21360
0
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21361
0
      offset = Z_REFVAL_P(offset);
21362
0
      goto add_again;
21363
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
21364
0
      str = ZSTR_EMPTY_ALLOC();
21365
0
      goto str_index;
21366
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21367
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21368
0
      goto num_index;
21369
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
21370
0
      hval = 0;
21371
0
      goto num_index;
21372
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
21373
0
      hval = 1;
21374
0
      goto num_index;
21375
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21376
0
      zend_use_resource_as_offset(offset);
21377
0
      hval = Z_RES_HANDLE_P(offset);
21378
0
      goto num_index;
21379
0
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21380
0
      ZVAL_UNDEFINED_OP2();
21381
0
      str = ZSTR_EMPTY_ALLOC();
21382
0
      goto str_index;
21383
0
    } else {
21384
0
      zend_illegal_array_offset_access(offset);
21385
0
      zval_ptr_dtor_nogc(expr_ptr);
21386
0
    }
21387
6
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21388
6
  } else {
21389
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21390
0
      zend_cannot_add_element();
21391
0
      zval_ptr_dtor_nogc(expr_ptr);
21392
0
    }
21393
0
  }
21394
6
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21395
6
}
21396
21397
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21398
0
{
21399
0
  zval *array;
21400
0
  uint32_t size;
21401
0
  USE_OPLINE
21402
21403
0
  SAVE_OPLINE();
21404
0
  array = EX_VAR(opline->result.var);
21405
0
  if (IS_TMP_VAR != IS_UNUSED) {
21406
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21407
0
    ZVAL_ARR(array, zend_new_array(size));
21408
    /* Explicitly initialize array as not-packed if flag is set */
21409
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21410
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21411
0
    }
21412
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21413
0
  } else {
21414
0
    ZVAL_ARR(array, zend_new_array(0));
21415
0
    ZEND_VM_NEXT_OPCODE();
21416
0
  }
21417
0
}
21418
21419
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21420
5
{
21421
5
  USE_OPLINE
21422
21423
5
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21424
21425
5
  SAVE_OPLINE();
21426
5
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21427
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21428
0
  }
21429
21430
  /* Destroy the previously yielded value */
21431
5
  zval_ptr_dtor(&generator->value);
21432
21433
  /* Destroy the previously yielded key */
21434
5
  zval_ptr_dtor(&generator->key);
21435
21436
  /* Set the new yielded value */
21437
5
  if (IS_TMP_VAR != IS_UNUSED) {
21438
5
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21439
      /* Constants and temporary variables aren't yieldable by reference,
21440
       * but we still allow them with a notice. */
21441
0
      if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21442
0
        zval *value;
21443
21444
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21445
21446
0
        value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21447
0
        ZVAL_COPY_VALUE(&generator->value, value);
21448
0
        if (IS_TMP_VAR == IS_CONST) {
21449
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21450
0
            Z_ADDREF(generator->value);
21451
0
          }
21452
0
        }
21453
0
      } else {
21454
0
        zval *value_ptr = zend_get_bad_ptr();
21455
21456
        /* If a function call result is yielded and the function did
21457
         * not return by reference we throw a notice. */
21458
0
        do {
21459
0
          if (IS_TMP_VAR == IS_VAR) {
21460
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21461
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
21462
0
             && !Z_ISREF_P(value_ptr)) {
21463
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21464
0
              ZVAL_COPY(&generator->value, value_ptr);
21465
0
              break;
21466
0
            }
21467
0
          }
21468
0
          if (Z_ISREF_P(value_ptr)) {
21469
0
            Z_ADDREF_P(value_ptr);
21470
0
          } else {
21471
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
21472
0
          }
21473
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21474
0
        } while (0);
21475
21476
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21477
0
      }
21478
5
    } else {
21479
5
      zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21480
21481
      /* Consts, temporary variables and references need copying */
21482
5
      if (IS_TMP_VAR == IS_CONST) {
21483
0
        ZVAL_COPY_VALUE(&generator->value, value);
21484
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21485
0
          Z_ADDREF(generator->value);
21486
0
        }
21487
5
      } else if (IS_TMP_VAR == IS_TMP_VAR) {
21488
5
        ZVAL_COPY_VALUE(&generator->value, value);
21489
5
      } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21490
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21491
21492
0
      } else {
21493
0
        ZVAL_COPY_VALUE(&generator->value, value);
21494
0
        if (IS_TMP_VAR == IS_CV) {
21495
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21496
0
        }
21497
0
      }
21498
5
    }
21499
5
  } else {
21500
    /* If no value was specified yield null */
21501
0
    ZVAL_NULL(&generator->value);
21502
0
  }
21503
21504
  /* Set the new yielded key */
21505
5
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
21506
5
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21507
5
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21508
0
      key = Z_REFVAL_P(key);
21509
0
    }
21510
5
    ZVAL_COPY(&generator->key, key);
21511
5
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21512
21513
5
    if (Z_TYPE(generator->key) == IS_LONG
21514
5
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
21515
5
    ) {
21516
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
21517
0
    }
21518
5
  } else {
21519
    /* If no key was specified we use auto-increment keys */
21520
0
    generator->largest_used_integer_key++;
21521
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21522
0
  }
21523
21524
5
  if (RETURN_VALUE_USED(opline)) {
21525
    /* If the return value of yield is used set the send
21526
     * target and initialize it to NULL */
21527
0
    generator->send_target = EX_VAR(opline->result.var);
21528
0
    ZVAL_NULL(generator->send_target);
21529
5
  } else {
21530
5
    generator->send_target = NULL;
21531
5
  }
21532
21533
  /* The GOTO VM uses a local opline variable. We need to set the opline
21534
   * variable in execute_data so we don't resume at an old position. */
21535
5
  SAVE_OPLINE();
21536
21537
5
  ZEND_VM_RETURN();
21538
5
}
21539
21540
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21541
102
{
21542
102
  USE_OPLINE
21543
102
  zval *op1, *op2;
21544
102
  bool result;
21545
21546
102
  SAVE_OPLINE();
21547
102
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21548
102
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21549
102
  result = fast_is_identical_function(op1, op2);
21550
102
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21551
102
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21552
102
  ZEND_VM_SMART_BRANCH(result, 1);
21553
102
}
21554
21555
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21556
245
{
21557
245
  USE_OPLINE
21558
245
  zval *op1, *op2;
21559
245
  bool result;
21560
21561
245
  SAVE_OPLINE();
21562
245
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21563
245
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21564
245
  result = fast_is_identical_function(op1, op2);
21565
245
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21566
245
  ZEND_VM_SMART_BRANCH(result, 1);
21567
245
}
21568
21569
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21570
2
{
21571
2
  USE_OPLINE
21572
2
  zval *op1, *op2;
21573
2
  bool result;
21574
21575
2
  SAVE_OPLINE();
21576
2
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21577
2
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21578
2
  result = fast_is_not_identical_function(op1, op2);
21579
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21580
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21581
2
  ZEND_VM_SMART_BRANCH(result, 1);
21582
2
}
21583
21584
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21585
0
{
21586
0
  USE_OPLINE
21587
0
  zval *op1, *op2;
21588
0
  bool result;
21589
21590
0
  SAVE_OPLINE();
21591
0
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21592
0
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
21593
0
  result = fast_is_identical_function(op1, op2);
21594
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21595
0
  ZEND_VM_SMART_BRANCH(result, 1);
21596
0
}
21597
21598
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21599
0
{
21600
#if 0
21601
  USE_OPLINE
21602
#endif
21603
21604
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21605
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21606
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21607
0
    }
21608
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21609
0
  } else {
21610
0
    if (IS_UNUSED == IS_UNUSED) {
21611
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21612
0
    }
21613
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21614
0
  }
21615
0
}
21616
21617
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21618
282
{
21619
282
  if (IS_TMP_VAR == IS_UNUSED) {
21620
0
    SAVE_OPLINE();
21621
0
    zend_verify_missing_return_type(EX(func));
21622
0
    HANDLE_EXCEPTION();
21623
282
  } else {
21624
/* prevents "undefined variable opline" errors */
21625
282
#if 0 || (IS_TMP_VAR != IS_UNUSED)
21626
282
    USE_OPLINE
21627
282
    zval *retval_ref, *retval_ptr;
21628
282
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
21629
282
    retval_ref = retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21630
21631
282
    if (IS_TMP_VAR == IS_CONST) {
21632
0
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
21633
0
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
21634
282
    } else if (IS_TMP_VAR == IS_VAR) {
21635
0
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
21636
0
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
21637
0
      }
21638
0
      ZVAL_DEREF(retval_ptr);
21639
282
    } else if (IS_TMP_VAR == IS_CV) {
21640
0
      ZVAL_DEREF(retval_ptr);
21641
0
    }
21642
21643
282
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
21644
196
      ZEND_VM_NEXT_OPCODE();
21645
196
    }
21646
21647
86
    if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
21648
0
      SAVE_OPLINE();
21649
0
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
21650
0
      if (UNEXPECTED(EG(exception))) {
21651
0
        HANDLE_EXCEPTION();
21652
0
      }
21653
0
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
21654
0
        ZEND_VM_NEXT_OPCODE();
21655
0
      }
21656
0
    }
21657
21658
86
    zend_reference *ref = NULL;
21659
86
    if (UNEXPECTED(retval_ref != retval_ptr)) {
21660
0
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21661
0
        ref = Z_REF_P(retval_ref);
21662
0
      } else {
21663
        /* A cast might happen - unwrap the reference if this is a by-value return */
21664
0
        if (Z_REFCOUNT_P(retval_ref) == 1) {
21665
0
          ZVAL_UNREF(retval_ref);
21666
0
        } else {
21667
0
          Z_DELREF_P(retval_ref);
21668
0
          ZVAL_COPY(retval_ref, retval_ptr);
21669
0
        }
21670
0
        retval_ptr = retval_ref;
21671
0
      }
21672
0
    }
21673
21674
86
    SAVE_OPLINE();
21675
86
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
21676
36
      zend_verify_return_error(EX(func), retval_ptr);
21677
36
      HANDLE_EXCEPTION();
21678
36
    }
21679
50
    ZEND_VM_NEXT_OPCODE();
21680
50
#endif
21681
50
  }
21682
282
}
21683
21684
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21685
0
{
21686
0
  USE_OPLINE
21687
0
  zval *value, *arg;
21688
0
  uint32_t arg_num;
21689
21690
0
  if (IS_UNUSED == IS_CONST) {
21691
0
    SAVE_OPLINE();
21692
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21693
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21694
0
    if (UNEXPECTED(!arg)) {
21695
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21696
0
      HANDLE_EXCEPTION();
21697
0
    }
21698
0
  } else {
21699
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21700
0
    arg_num = opline->op2.num;
21701
0
  }
21702
21703
0
  if (EXPECTED(0)) {
21704
0
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21705
0
      goto send_val_by_ref;
21706
0
    }
21707
0
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21708
0
send_val_by_ref:
21709
0
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
21710
0
  }
21711
0
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21712
0
  ZVAL_COPY_VALUE(arg, value);
21713
0
  if (IS_TMP_VAR == IS_CONST) {
21714
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21715
0
      Z_ADDREF_P(arg);
21716
0
    }
21717
0
  }
21718
0
  ZEND_VM_NEXT_OPCODE();
21719
0
}
21720
21721
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21722
4.61k
{
21723
4.61k
  USE_OPLINE
21724
4.61k
  zval *value, *arg;
21725
4.61k
  uint32_t arg_num;
21726
21727
4.61k
  if (IS_UNUSED == IS_CONST) {
21728
0
    SAVE_OPLINE();
21729
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21730
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21731
0
    if (UNEXPECTED(!arg)) {
21732
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21733
0
      HANDLE_EXCEPTION();
21734
0
    }
21735
4.61k
  } else {
21736
4.61k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21737
4.61k
    arg_num = opline->op2.num;
21738
4.61k
  }
21739
21740
4.61k
  if (EXPECTED(1)) {
21741
4.61k
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21742
84
      goto send_val_by_ref;
21743
84
    }
21744
4.61k
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21745
84
send_val_by_ref:
21746
84
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
21747
0
  }
21748
4.53k
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21749
4.53k
  ZVAL_COPY_VALUE(arg, value);
21750
4.53k
  if (IS_TMP_VAR == IS_CONST) {
21751
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21752
0
      Z_ADDREF_P(arg);
21753
0
    }
21754
0
  }
21755
4.53k
  ZEND_VM_NEXT_OPCODE();
21756
4.53k
}
21757
21758
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21759
9.93k
{
21760
9.93k
  USE_OPLINE
21761
9.93k
  zval *expr_ptr, new_expr;
21762
21763
9.93k
  SAVE_OPLINE();
21764
9.93k
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21765
9.93k
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21766
0
    expr_ptr = zend_get_bad_ptr();
21767
0
    if (Z_ISREF_P(expr_ptr)) {
21768
0
      Z_ADDREF_P(expr_ptr);
21769
0
    } else {
21770
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
21771
0
    }
21772
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21773
9.93k
  } else {
21774
9.93k
    expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21775
9.93k
    if (IS_TMP_VAR == IS_TMP_VAR) {
21776
      /* pass */
21777
9.93k
    } else if (IS_TMP_VAR == IS_CONST) {
21778
0
      Z_TRY_ADDREF_P(expr_ptr);
21779
0
    } else if (IS_TMP_VAR == IS_CV) {
21780
0
      ZVAL_DEREF(expr_ptr);
21781
0
      Z_TRY_ADDREF_P(expr_ptr);
21782
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
21783
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21784
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21785
21786
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
21787
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21788
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21789
0
          expr_ptr = &new_expr;
21790
0
          efree_size(ref, sizeof(zend_reference));
21791
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21792
0
          Z_ADDREF_P(expr_ptr);
21793
0
        }
21794
0
      }
21795
0
    }
21796
9.93k
  }
21797
21798
9.93k
  if (IS_UNUSED != IS_UNUSED) {
21799
0
    zval *offset = NULL;
21800
0
    zend_string *str;
21801
0
    zend_ulong hval;
21802
21803
0
add_again:
21804
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21805
0
      str = Z_STR_P(offset);
21806
0
      if (IS_UNUSED != IS_CONST) {
21807
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
21808
0
          goto num_index;
21809
0
        }
21810
0
      }
21811
0
str_index:
21812
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21813
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21814
0
      hval = Z_LVAL_P(offset);
21815
0
num_index:
21816
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21817
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21818
0
      offset = Z_REFVAL_P(offset);
21819
0
      goto add_again;
21820
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
21821
0
      str = ZSTR_EMPTY_ALLOC();
21822
0
      goto str_index;
21823
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21824
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21825
0
      goto num_index;
21826
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
21827
0
      hval = 0;
21828
0
      goto num_index;
21829
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
21830
0
      hval = 1;
21831
0
      goto num_index;
21832
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21833
0
      zend_use_resource_as_offset(offset);
21834
0
      hval = Z_RES_HANDLE_P(offset);
21835
0
      goto num_index;
21836
0
    } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21837
0
      ZVAL_UNDEFINED_OP2();
21838
0
      str = ZSTR_EMPTY_ALLOC();
21839
0
      goto str_index;
21840
0
    } else {
21841
0
      zend_illegal_array_offset_access(offset);
21842
0
      zval_ptr_dtor_nogc(expr_ptr);
21843
0
    }
21844
21845
9.93k
  } else {
21846
9.93k
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21847
0
      zend_cannot_add_element();
21848
0
      zval_ptr_dtor_nogc(expr_ptr);
21849
0
    }
21850
9.93k
  }
21851
9.93k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21852
9.93k
}
21853
21854
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21855
1.42k
{
21856
1.42k
  zval *array;
21857
1.42k
  uint32_t size;
21858
1.42k
  USE_OPLINE
21859
21860
1.42k
  SAVE_OPLINE();
21861
1.42k
  array = EX_VAR(opline->result.var);
21862
1.42k
  if (IS_TMP_VAR != IS_UNUSED) {
21863
1.42k
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21864
1.42k
    ZVAL_ARR(array, zend_new_array(size));
21865
    /* Explicitly initialize array as not-packed if flag is set */
21866
1.42k
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21867
65
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21868
65
    }
21869
1.42k
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21870
1.42k
  } else {
21871
0
    ZVAL_ARR(array, zend_new_array(0));
21872
0
    ZEND_VM_NEXT_OPCODE();
21873
0
  }
21874
1.42k
}
21875
21876
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21877
401
{
21878
401
  USE_OPLINE
21879
21880
401
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21881
21882
401
  SAVE_OPLINE();
21883
401
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21884
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21885
0
  }
21886
21887
  /* Destroy the previously yielded value */
21888
401
  zval_ptr_dtor(&generator->value);
21889
21890
  /* Destroy the previously yielded key */
21891
401
  zval_ptr_dtor(&generator->key);
21892
21893
  /* Set the new yielded value */
21894
401
  if (IS_TMP_VAR != IS_UNUSED) {
21895
401
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21896
      /* Constants and temporary variables aren't yieldable by reference,
21897
       * but we still allow them with a notice. */
21898
15
      if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21899
15
        zval *value;
21900
21901
15
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21902
21903
15
        value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21904
15
        ZVAL_COPY_VALUE(&generator->value, value);
21905
15
        if (IS_TMP_VAR == IS_CONST) {
21906
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21907
0
            Z_ADDREF(generator->value);
21908
0
          }
21909
0
        }
21910
15
      } else {
21911
0
        zval *value_ptr = zend_get_bad_ptr();
21912
21913
        /* If a function call result is yielded and the function did
21914
         * not return by reference we throw a notice. */
21915
0
        do {
21916
0
          if (IS_TMP_VAR == IS_VAR) {
21917
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21918
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
21919
0
             && !Z_ISREF_P(value_ptr)) {
21920
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21921
0
              ZVAL_COPY(&generator->value, value_ptr);
21922
0
              break;
21923
0
            }
21924
0
          }
21925
0
          if (Z_ISREF_P(value_ptr)) {
21926
0
            Z_ADDREF_P(value_ptr);
21927
0
          } else {
21928
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
21929
0
          }
21930
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21931
0
        } while (0);
21932
21933
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21934
0
      }
21935
386
    } else {
21936
386
      zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21937
21938
      /* Consts, temporary variables and references need copying */
21939
386
      if (IS_TMP_VAR == IS_CONST) {
21940
0
        ZVAL_COPY_VALUE(&generator->value, value);
21941
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21942
0
          Z_ADDREF(generator->value);
21943
0
        }
21944
386
      } else if (IS_TMP_VAR == IS_TMP_VAR) {
21945
386
        ZVAL_COPY_VALUE(&generator->value, value);
21946
386
      } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21947
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21948
21949
0
      } else {
21950
0
        ZVAL_COPY_VALUE(&generator->value, value);
21951
0
        if (IS_TMP_VAR == IS_CV) {
21952
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21953
0
        }
21954
0
      }
21955
386
    }
21956
401
  } else {
21957
    /* If no value was specified yield null */
21958
0
    ZVAL_NULL(&generator->value);
21959
0
  }
21960
21961
  /* Set the new yielded key */
21962
401
  if (IS_UNUSED != IS_UNUSED) {
21963
0
    zval *key = NULL;
21964
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21965
0
      key = Z_REFVAL_P(key);
21966
0
    }
21967
0
    ZVAL_COPY(&generator->key, key);
21968
21969
0
    if (Z_TYPE(generator->key) == IS_LONG
21970
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
21971
0
    ) {
21972
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
21973
0
    }
21974
401
  } else {
21975
    /* If no key was specified we use auto-increment keys */
21976
401
    generator->largest_used_integer_key++;
21977
401
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21978
401
  }
21979
21980
401
  if (RETURN_VALUE_USED(opline)) {
21981
    /* If the return value of yield is used set the send
21982
     * target and initialize it to NULL */
21983
63
    generator->send_target = EX_VAR(opline->result.var);
21984
63
    ZVAL_NULL(generator->send_target);
21985
338
  } else {
21986
338
    generator->send_target = NULL;
21987
338
  }
21988
21989
  /* The GOTO VM uses a local opline variable. We need to set the opline
21990
   * variable in execute_data so we don't resume at an old position. */
21991
401
  SAVE_OPLINE();
21992
21993
401
  ZEND_VM_RETURN();
21994
401
}
21995
21996
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21997
142
{
21998
142
  USE_OPLINE
21999
142
  zval *op1;
22000
142
  zend_string *type;
22001
22002
142
  SAVE_OPLINE();
22003
142
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22004
142
  type = zend_zval_get_legacy_type(op1);
22005
142
  if (EXPECTED(type)) {
22006
142
    ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
22007
142
  } else {
22008
0
    ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
22009
0
  }
22010
142
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22011
142
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22012
142
}
22013
22014
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22015
0
{
22016
0
  USE_OPLINE
22017
0
  zval *op1, *op2;
22018
0
  bool result;
22019
22020
0
  SAVE_OPLINE();
22021
0
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22022
0
  op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22023
0
  result = fast_is_identical_function(op1, op2);
22024
22025
0
  ZEND_VM_SMART_BRANCH(result, 1);
22026
0
}
22027
22028
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22029
0
{
22030
#if 0
22031
  USE_OPLINE
22032
#endif
22033
22034
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
22035
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
22036
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22037
0
    }
22038
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22039
0
  } else {
22040
0
    if (IS_CV == IS_UNUSED) {
22041
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22042
0
    }
22043
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22044
0
  }
22045
0
}
22046
22047
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22048
0
{
22049
#if 0
22050
  USE_OPLINE
22051
#endif
22052
22053
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
22054
    /* Behave like FETCH_OBJ_W */
22055
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
22056
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22057
0
    }
22058
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22059
0
  } else {
22060
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22061
0
  }
22062
0
}
22063
22064
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22065
655k
{
22066
655k
  USE_OPLINE
22067
655k
  zend_string **rope;
22068
655k
  zval *var;
22069
22070
  /* op1 and result are the same */
22071
655k
  rope = (zend_string**)EX_VAR(opline->op1.var);
22072
655k
  if (IS_CV == IS_CONST) {
22073
0
    var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22074
0
    rope[opline->extended_value] = Z_STR_P(var);
22075
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
22076
0
      Z_ADDREF_P(var);
22077
0
    }
22078
655k
  } else {
22079
655k
    var = EX_VAR(opline->op2.var);
22080
655k
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
22081
238k
      if (IS_CV == IS_CV) {
22082
238k
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
22083
238k
      } else {
22084
0
        rope[opline->extended_value] = Z_STR_P(var);
22085
0
      }
22086
417k
    } else {
22087
417k
      SAVE_OPLINE();
22088
417k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
22089
399k
        ZVAL_UNDEFINED_OP2();
22090
399k
      }
22091
417k
      rope[opline->extended_value] = zval_get_string_func(var);
22092
22093
417k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22094
417k
    }
22095
655k
  }
22096
238k
  ZEND_VM_NEXT_OPCODE();
22097
238k
}
22098
22099
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22100
3.30k
{
22101
3.30k
  USE_OPLINE
22102
3.30k
  zend_string **rope;
22103
3.30k
  zval *var, *ret;
22104
3.30k
  uint32_t i;
22105
22106
3.30k
  rope = (zend_string**)EX_VAR(opline->op1.var);
22107
3.30k
  if (IS_CV == IS_CONST) {
22108
0
    var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22109
0
    rope[opline->extended_value] = Z_STR_P(var);
22110
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
22111
0
      Z_ADDREF_P(var);
22112
0
    }
22113
3.30k
  } else {
22114
3.30k
    var = EX_VAR(opline->op2.var);
22115
3.30k
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
22116
30
      if (IS_CV == IS_CV) {
22117
30
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
22118
30
      } else {
22119
0
        rope[opline->extended_value] = Z_STR_P(var);
22120
0
      }
22121
3.27k
    } else {
22122
3.27k
      SAVE_OPLINE();
22123
3.27k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
22124
3.03k
        ZVAL_UNDEFINED_OP2();
22125
3.03k
      }
22126
3.27k
      rope[opline->extended_value] = zval_get_string_func(var);
22127
22128
3.27k
      if (UNEXPECTED(EG(exception))) {
22129
108
        for (i = 0; i <= opline->extended_value; i++) {
22130
81
          zend_string_release_ex(rope[i], 0);
22131
81
        }
22132
27
        ZVAL_UNDEF(EX_VAR(opline->result.var));
22133
27
        HANDLE_EXCEPTION();
22134
27
      }
22135
3.27k
    }
22136
3.30k
  }
22137
22138
3.27k
  size_t len = 0;
22139
3.27k
  uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
22140
46.6k
  for (i = 0; i <= opline->extended_value; i++) {
22141
43.3k
    flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
22142
43.3k
    len += ZSTR_LEN(rope[i]);
22143
43.3k
  }
22144
3.27k
  ret = EX_VAR(opline->result.var);
22145
3.27k
  ZVAL_STR(ret, zend_string_alloc(len, 0));
22146
3.27k
  GC_ADD_FLAGS(Z_STR_P(ret), flags);
22147
22148
3.27k
  char *target = Z_STRVAL_P(ret);
22149
46.6k
  for (i = 0; i <= opline->extended_value; i++) {
22150
43.3k
    memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
22151
43.3k
    target += ZSTR_LEN(rope[i]);
22152
43.3k
    zend_string_release_ex(rope[i], 0);
22153
43.3k
  }
22154
3.27k
  *target = '\0';
22155
22156
3.27k
  ZEND_VM_NEXT_OPCODE();
22157
3.27k
}
22158
22159
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22160
0
{
22161
0
  USE_OPLINE
22162
0
  zval *expr_ptr, new_expr;
22163
22164
0
  SAVE_OPLINE();
22165
0
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
22166
0
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
22167
0
    expr_ptr = zend_get_bad_ptr();
22168
0
    if (Z_ISREF_P(expr_ptr)) {
22169
0
      Z_ADDREF_P(expr_ptr);
22170
0
    } else {
22171
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
22172
0
    }
22173
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22174
0
  } else {
22175
0
    expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22176
0
    if (IS_TMP_VAR == IS_TMP_VAR) {
22177
      /* pass */
22178
0
    } else if (IS_TMP_VAR == IS_CONST) {
22179
0
      Z_TRY_ADDREF_P(expr_ptr);
22180
0
    } else if (IS_TMP_VAR == IS_CV) {
22181
0
      ZVAL_DEREF(expr_ptr);
22182
0
      Z_TRY_ADDREF_P(expr_ptr);
22183
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
22184
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
22185
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
22186
22187
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
22188
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22189
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
22190
0
          expr_ptr = &new_expr;
22191
0
          efree_size(ref, sizeof(zend_reference));
22192
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
22193
0
          Z_ADDREF_P(expr_ptr);
22194
0
        }
22195
0
      }
22196
0
    }
22197
0
  }
22198
22199
0
  if (IS_CV != IS_UNUSED) {
22200
0
    zval *offset = EX_VAR(opline->op2.var);
22201
0
    zend_string *str;
22202
0
    zend_ulong hval;
22203
22204
0
add_again:
22205
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
22206
0
      str = Z_STR_P(offset);
22207
0
      if (IS_CV != IS_CONST) {
22208
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
22209
0
          goto num_index;
22210
0
        }
22211
0
      }
22212
0
str_index:
22213
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
22214
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
22215
0
      hval = Z_LVAL_P(offset);
22216
0
num_index:
22217
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
22218
0
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
22219
0
      offset = Z_REFVAL_P(offset);
22220
0
      goto add_again;
22221
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
22222
0
      str = ZSTR_EMPTY_ALLOC();
22223
0
      goto str_index;
22224
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
22225
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
22226
0
      goto num_index;
22227
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
22228
0
      hval = 0;
22229
0
      goto num_index;
22230
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
22231
0
      hval = 1;
22232
0
      goto num_index;
22233
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
22234
0
      zend_use_resource_as_offset(offset);
22235
0
      hval = Z_RES_HANDLE_P(offset);
22236
0
      goto num_index;
22237
0
    } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
22238
0
      ZVAL_UNDEFINED_OP2();
22239
0
      str = ZSTR_EMPTY_ALLOC();
22240
0
      goto str_index;
22241
0
    } else {
22242
0
      zend_illegal_array_offset_access(offset);
22243
0
      zval_ptr_dtor_nogc(expr_ptr);
22244
0
    }
22245
22246
0
  } else {
22247
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
22248
0
      zend_cannot_add_element();
22249
0
      zval_ptr_dtor_nogc(expr_ptr);
22250
0
    }
22251
0
  }
22252
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22253
0
}
22254
22255
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22256
0
{
22257
0
  zval *array;
22258
0
  uint32_t size;
22259
0
  USE_OPLINE
22260
22261
0
  SAVE_OPLINE();
22262
0
  array = EX_VAR(opline->result.var);
22263
0
  if (IS_TMP_VAR != IS_UNUSED) {
22264
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
22265
0
    ZVAL_ARR(array, zend_new_array(size));
22266
    /* Explicitly initialize array as not-packed if flag is set */
22267
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
22268
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
22269
0
    }
22270
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22271
0
  } else {
22272
0
    ZVAL_ARR(array, zend_new_array(0));
22273
0
    ZEND_VM_NEXT_OPCODE();
22274
0
  }
22275
0
}
22276
22277
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22278
0
{
22279
0
  USE_OPLINE
22280
22281
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22282
22283
0
  SAVE_OPLINE();
22284
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
22285
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22286
0
  }
22287
22288
  /* Destroy the previously yielded value */
22289
0
  zval_ptr_dtor(&generator->value);
22290
22291
  /* Destroy the previously yielded key */
22292
0
  zval_ptr_dtor(&generator->key);
22293
22294
  /* Set the new yielded value */
22295
0
  if (IS_TMP_VAR != IS_UNUSED) {
22296
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
22297
      /* Constants and temporary variables aren't yieldable by reference,
22298
       * but we still allow them with a notice. */
22299
0
      if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
22300
0
        zval *value;
22301
22302
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22303
22304
0
        value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22305
0
        ZVAL_COPY_VALUE(&generator->value, value);
22306
0
        if (IS_TMP_VAR == IS_CONST) {
22307
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
22308
0
            Z_ADDREF(generator->value);
22309
0
          }
22310
0
        }
22311
0
      } else {
22312
0
        zval *value_ptr = zend_get_bad_ptr();
22313
22314
        /* If a function call result is yielded and the function did
22315
         * not return by reference we throw a notice. */
22316
0
        do {
22317
0
          if (IS_TMP_VAR == IS_VAR) {
22318
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
22319
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
22320
0
             && !Z_ISREF_P(value_ptr)) {
22321
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22322
0
              ZVAL_COPY(&generator->value, value_ptr);
22323
0
              break;
22324
0
            }
22325
0
          }
22326
0
          if (Z_ISREF_P(value_ptr)) {
22327
0
            Z_ADDREF_P(value_ptr);
22328
0
          } else {
22329
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
22330
0
          }
22331
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
22332
0
        } while (0);
22333
22334
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22335
0
      }
22336
0
    } else {
22337
0
      zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22338
22339
      /* Consts, temporary variables and references need copying */
22340
0
      if (IS_TMP_VAR == IS_CONST) {
22341
0
        ZVAL_COPY_VALUE(&generator->value, value);
22342
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
22343
0
          Z_ADDREF(generator->value);
22344
0
        }
22345
0
      } else if (IS_TMP_VAR == IS_TMP_VAR) {
22346
0
        ZVAL_COPY_VALUE(&generator->value, value);
22347
0
      } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
22348
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
22349
22350
0
      } else {
22351
0
        ZVAL_COPY_VALUE(&generator->value, value);
22352
0
        if (IS_TMP_VAR == IS_CV) {
22353
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
22354
0
        }
22355
0
      }
22356
0
    }
22357
0
  } else {
22358
    /* If no value was specified yield null */
22359
0
    ZVAL_NULL(&generator->value);
22360
0
  }
22361
22362
  /* Set the new yielded key */
22363
0
  if (IS_CV != IS_UNUSED) {
22364
0
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22365
0
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
22366
0
      key = Z_REFVAL_P(key);
22367
0
    }
22368
0
    ZVAL_COPY(&generator->key, key);
22369
22370
0
    if (Z_TYPE(generator->key) == IS_LONG
22371
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
22372
0
    ) {
22373
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
22374
0
    }
22375
0
  } else {
22376
    /* If no key was specified we use auto-increment keys */
22377
0
    generator->largest_used_integer_key++;
22378
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
22379
0
  }
22380
22381
0
  if (RETURN_VALUE_USED(opline)) {
22382
    /* If the return value of yield is used set the send
22383
     * target and initialize it to NULL */
22384
0
    generator->send_target = EX_VAR(opline->result.var);
22385
0
    ZVAL_NULL(generator->send_target);
22386
0
  } else {
22387
0
    generator->send_target = NULL;
22388
0
  }
22389
22390
  /* The GOTO VM uses a local opline variable. We need to set the opline
22391
   * variable in execute_data so we don't resume at an old position. */
22392
0
  SAVE_OPLINE();
22393
22394
0
  ZEND_VM_RETURN();
22395
0
}
22396
22397
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22398
7.17k
{
22399
7.17k
  USE_OPLINE
22400
7.17k
  zval *closure, *var;
22401
22402
7.17k
  closure = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22403
7.17k
  if (opline->extended_value & ZEND_BIND_REF) {
22404
    /* By-ref binding */
22405
1.08k
    var = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
22406
1.08k
    if (Z_ISREF_P(var)) {
22407
375
      Z_ADDREF_P(var);
22408
705
    } else {
22409
705
      ZVAL_MAKE_REF_EX(var, 2);
22410
705
    }
22411
6.09k
  } else {
22412
6.09k
    var = EX_VAR(opline->op2.var);
22413
6.09k
    if (UNEXPECTED(Z_ISUNDEF_P(var)) && !(opline->extended_value & ZEND_BIND_IMPLICIT)) {
22414
228
      SAVE_OPLINE();
22415
228
      var = ZVAL_UNDEFINED_OP2();
22416
228
      if (UNEXPECTED(EG(exception))) {
22417
2
        HANDLE_EXCEPTION();
22418
2
      }
22419
228
    }
22420
6.09k
    ZVAL_DEREF(var);
22421
6.09k
    Z_TRY_ADDREF_P(var);
22422
6.09k
  }
22423
22424
7.17k
  zend_closure_bind_var_ex(closure,
22425
7.17k
    (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT)), var);
22426
7.17k
  ZEND_VM_NEXT_OPCODE();
22427
7.17k
}
22428
22429
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22430
180
{
22431
180
  USE_OPLINE
22432
180
  zval *var_ptr;
22433
22434
180
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22435
22436
180
  SAVE_OPLINE();
22437
180
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22438
0
    ZVAL_UNDEFINED_OP1();
22439
0
    ZVAL_NULL(var_ptr);
22440
0
  }
22441
22442
180
  do {
22443
180
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22444
53
      zend_reference *ref = Z_REF_P(var_ptr);
22445
53
      var_ptr = Z_REFVAL_P(var_ptr);
22446
53
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22447
35
        zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
22448
35
        break;
22449
35
      }
22450
53
    }
22451
145
    increment_function(var_ptr);
22452
145
  } while (0);
22453
22454
180
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
22455
13
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22456
13
  }
22457
22458
180
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22459
180
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22460
180
}
22461
22462
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22463
758
{
22464
758
  USE_OPLINE
22465
758
  zval *var_ptr;
22466
22467
758
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22468
22469
758
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22470
591
    fast_long_increment_function(var_ptr);
22471
591
    if (UNEXPECTED(0)) {
22472
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22473
0
    }
22474
591
    ZEND_VM_NEXT_OPCODE();
22475
591
  }
22476
22477
758
  ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22478
758
}
22479
22480
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22481
13
{
22482
13
  USE_OPLINE
22483
13
  zval *var_ptr;
22484
22485
13
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22486
22487
13
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22488
0
    fast_long_increment_function(var_ptr);
22489
0
    if (UNEXPECTED(1)) {
22490
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22491
0
    }
22492
0
    ZEND_VM_NEXT_OPCODE();
22493
0
  }
22494
22495
13
  ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22496
13
}
22497
22498
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22499
322
{
22500
322
  USE_OPLINE
22501
322
  zval *var_ptr;
22502
22503
322
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22504
22505
322
  SAVE_OPLINE();
22506
322
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22507
0
    ZVAL_UNDEFINED_OP1();
22508
0
    ZVAL_NULL(var_ptr);
22509
0
  }
22510
22511
322
  do {
22512
322
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22513
99
      zend_reference *ref = Z_REF_P(var_ptr);
22514
99
      var_ptr = Z_REFVAL_P(var_ptr);
22515
22516
99
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22517
99
        zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
22518
99
        break;
22519
99
      }
22520
99
    }
22521
223
    decrement_function(var_ptr);
22522
223
  } while (0);
22523
22524
322
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
22525
83
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22526
83
  }
22527
22528
322
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22529
322
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22530
322
}
22531
22532
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22533
239
{
22534
239
  USE_OPLINE
22535
239
  zval *var_ptr;
22536
22537
239
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22538
22539
239
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22540
0
    fast_long_decrement_function(var_ptr);
22541
0
    if (UNEXPECTED(0)) {
22542
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22543
0
    }
22544
0
    ZEND_VM_NEXT_OPCODE();
22545
0
  }
22546
22547
239
  ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22548
239
}
22549
22550
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22551
125
{
22552
125
  USE_OPLINE
22553
125
  zval *var_ptr;
22554
22555
125
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22556
22557
125
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22558
42
    fast_long_decrement_function(var_ptr);
22559
42
    if (UNEXPECTED(1)) {
22560
42
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22561
42
    }
22562
42
    ZEND_VM_NEXT_OPCODE();
22563
42
  }
22564
22565
125
  ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22566
125
}
22567
22568
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22569
8
{
22570
8
  USE_OPLINE
22571
8
  zval *var_ptr;
22572
22573
8
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22574
22575
8
  SAVE_OPLINE();
22576
8
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22577
0
    ZVAL_UNDEFINED_OP1();
22578
0
    ZVAL_NULL(var_ptr);
22579
0
  }
22580
22581
8
  do {
22582
8
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22583
0
      zend_reference *ref = Z_REF_P(var_ptr);
22584
0
      var_ptr = Z_REFVAL_P(var_ptr);
22585
22586
0
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22587
0
        zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
22588
0
        break;
22589
0
      }
22590
0
    }
22591
8
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22592
22593
8
    increment_function(var_ptr);
22594
8
  } while (0);
22595
22596
8
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22597
8
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22598
8
}
22599
22600
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22601
8
{
22602
8
  USE_OPLINE
22603
8
  zval *var_ptr;
22604
22605
8
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22606
22607
8
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22608
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
22609
0
    fast_long_increment_function(var_ptr);
22610
0
    ZEND_VM_NEXT_OPCODE();
22611
0
  }
22612
22613
8
  ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22614
8
}
22615
22616
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22617
71
{
22618
71
  USE_OPLINE
22619
71
  zval *var_ptr;
22620
22621
71
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22622
22623
71
  SAVE_OPLINE();
22624
71
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22625
0
    ZVAL_UNDEFINED_OP1();
22626
0
    ZVAL_NULL(var_ptr);
22627
0
  }
22628
22629
71
  do {
22630
71
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22631
0
      zend_reference *ref = Z_REF_P(var_ptr);
22632
0
      var_ptr = Z_REFVAL_P(var_ptr);
22633
22634
0
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22635
0
        zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
22636
0
        break;
22637
0
      }
22638
0
    }
22639
71
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22640
22641
71
    decrement_function(var_ptr);
22642
71
  } while (0);
22643
22644
71
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22645
71
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22646
71
}
22647
22648
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22649
71
{
22650
71
  USE_OPLINE
22651
71
  zval *var_ptr;
22652
22653
71
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22654
22655
71
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22656
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
22657
0
    fast_long_decrement_function(var_ptr);
22658
0
    ZEND_VM_NEXT_OPCODE();
22659
0
  }
22660
22661
71
  ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22662
71
}
22663
22664
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22665
5.75k
{
22666
5.75k
  USE_OPLINE
22667
5.75k
  zval *retval_ptr;
22668
5.75k
  zval *return_value;
22669
22670
5.75k
  retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22671
5.75k
  return_value = EX(return_value);
22672
22673
5.75k
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
22674
0
    SAVE_OPLINE();
22675
0
    retval_ptr = ZVAL_UNDEFINED_OP1();
22676
0
    if (return_value) {
22677
0
      ZVAL_NULL(return_value);
22678
0
    }
22679
5.75k
  } else if (!return_value) {
22680
883
    if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
22681
883
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
22682
731
        SAVE_OPLINE();
22683
731
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
22684
731
      }
22685
883
    }
22686
4.87k
  } else {
22687
4.87k
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22688
0
      ZVAL_COPY_VALUE(return_value, retval_ptr);
22689
0
      if (IS_VAR == IS_CONST) {
22690
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
22691
0
          Z_ADDREF_P(return_value);
22692
0
        }
22693
0
      }
22694
4.87k
    } else if (IS_VAR == IS_CV) {
22695
0
      do {
22696
0
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22697
0
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
22698
0
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
22699
0
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22700
0
              ZVAL_COPY_VALUE(return_value, retval_ptr);
22701
0
              if (GC_MAY_LEAK(ref)) {
22702
0
                SAVE_OPLINE();
22703
0
                gc_possible_root(ref);
22704
0
              }
22705
0
              ZVAL_NULL(retval_ptr);
22706
0
              break;
22707
0
            } else {
22708
0
              Z_ADDREF_P(retval_ptr);
22709
0
            }
22710
0
          } else {
22711
0
            retval_ptr = Z_REFVAL_P(retval_ptr);
22712
0
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22713
0
              Z_ADDREF_P(retval_ptr);
22714
0
            }
22715
0
          }
22716
0
        }
22717
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
22718
0
      } while (0);
22719
4.87k
    } else /* if (IS_VAR == IS_VAR) */ {
22720
4.87k
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22721
10
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22722
22723
10
        retval_ptr = Z_REFVAL_P(retval_ptr);
22724
10
        ZVAL_COPY_VALUE(return_value, retval_ptr);
22725
10
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22726
10
          efree_size(ref, sizeof(zend_reference));
22727
10
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22728
0
          Z_ADDREF_P(retval_ptr);
22729
0
        }
22730
4.86k
      } else {
22731
4.86k
        ZVAL_COPY_VALUE(return_value, retval_ptr);
22732
4.86k
      }
22733
4.87k
    }
22734
4.87k
  }
22735
22736
22737
22738
5.75k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22739
5.75k
}
22740
22741
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22742
1.05k
{
22743
1.05k
  USE_OPLINE
22744
1.05k
  zval *retval_ptr;
22745
1.05k
  zval *return_value;
22746
22747
1.05k
  SAVE_OPLINE();
22748
22749
1.05k
  return_value = EX(return_value);
22750
22751
1.05k
  do {
22752
1.05k
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR)) ||
22753
1.05k
        (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
22754
      /* Not supposed to happen, but we'll allow it */
22755
0
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
22756
22757
0
      retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22758
0
      if (!return_value) {
22759
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22760
0
      } else {
22761
0
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22762
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
22763
0
          break;
22764
0
        }
22765
22766
0
        ZVAL_NEW_REF(return_value, retval_ptr);
22767
0
        if (IS_VAR == IS_CONST) {
22768
0
          Z_TRY_ADDREF_P(retval_ptr);
22769
0
        }
22770
0
      }
22771
0
      break;
22772
0
    }
22773
22774
1.05k
    retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22775
22776
1.05k
    if (IS_VAR == IS_VAR) {
22777
1.05k
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
22778
1.05k
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
22779
13
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
22780
13
        if (return_value) {
22781
13
          ZVAL_NEW_REF(return_value, retval_ptr);
22782
13
        } else {
22783
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22784
0
        }
22785
13
        break;
22786
13
      }
22787
1.05k
    }
22788
22789
1.04k
    if (return_value) {
22790
1.04k
      if (Z_ISREF_P(retval_ptr)) {
22791
660
        Z_ADDREF_P(retval_ptr);
22792
660
      } else {
22793
384
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
22794
384
      }
22795
1.04k
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
22796
1.04k
    }
22797
22798
1.04k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22799
1.04k
  } while (0);
22800
22801
22802
1.05k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22803
1.05k
}
22804
22805
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22806
10
{
22807
10
  USE_OPLINE
22808
10
  zval *retval;
22809
22810
10
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22811
22812
10
  SAVE_OPLINE();
22813
10
  retval = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22814
22815
  /* Copy return value into generator->retval */
22816
10
  if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22817
0
    ZVAL_COPY_VALUE(&generator->retval, retval);
22818
0
    if (IS_VAR == IS_CONST) {
22819
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
22820
0
        Z_ADDREF(generator->retval);
22821
0
      }
22822
0
    }
22823
10
  } else if (IS_VAR == IS_CV) {
22824
0
    ZVAL_COPY_DEREF(&generator->retval, retval);
22825
10
  } else /* if (IS_VAR == IS_VAR) */ {
22826
10
    if (UNEXPECTED(Z_ISREF_P(retval))) {
22827
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
22828
22829
0
      retval = Z_REFVAL_P(retval);
22830
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
22831
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22832
0
        efree_size(ref, sizeof(zend_reference));
22833
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
22834
0
        Z_ADDREF_P(retval);
22835
0
      }
22836
10
    } else {
22837
10
      ZVAL_COPY_VALUE(&generator->retval, retval);
22838
10
    }
22839
10
  }
22840
22841
10
  EG(current_execute_data) = EX(prev_execute_data);
22842
22843
  /* Close the generator to free up resources */
22844
10
  zend_generator_close(generator, 1);
22845
22846
  /* Pass execution back to handling code */
22847
10
  ZEND_VM_RETURN();
22848
10
}
22849
22850
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22851
5
{
22852
5
  USE_OPLINE
22853
5
  zval *arg, *param;
22854
22855
5
  SAVE_OPLINE();
22856
22857
5
  arg = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22858
5
  param = ZEND_CALL_VAR(EX(call), opline->result.var);
22859
5
  if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
22860
5
    zend_param_must_be_ref(EX(call)->func, opline->op2.num);
22861
5
    Z_TRY_ADDREF_P(arg);
22862
5
    ZVAL_NEW_REF(param, arg);
22863
5
  } else {
22864
0
    ZVAL_COPY(param, arg);
22865
0
  }
22866
22867
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22868
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22869
5
}
22870
22871
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22872
6.16k
{
22873
6.16k
  USE_OPLINE
22874
6.16k
  zval *expr;
22875
6.16k
  zval *result = EX_VAR(opline->result.var);
22876
22877
6.16k
  SAVE_OPLINE();
22878
6.16k
  expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22879
22880
6.16k
  switch (opline->extended_value) {
22881
25
    case IS_LONG:
22882
25
      ZVAL_LONG(result, zval_get_long(expr));
22883
25
      break;
22884
5.93k
    case IS_DOUBLE:
22885
5.93k
      ZVAL_DOUBLE(result, zval_get_double(expr));
22886
5.93k
      break;
22887
98
    case IS_STRING:
22888
98
      ZVAL_STR(result, zval_get_string(expr));
22889
98
      break;
22890
112
    default:
22891
112
      ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
22892
112
      if (IS_VAR & (IS_VAR|IS_CV)) {
22893
112
        ZVAL_DEREF(expr);
22894
112
      }
22895
      /* If value is already of correct type, return it directly */
22896
112
      if (Z_TYPE_P(expr) == opline->extended_value) {
22897
105
        ZVAL_COPY_VALUE(result, expr);
22898
105
        if (IS_VAR == IS_CONST) {
22899
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22900
105
        } else if (IS_VAR != IS_TMP_VAR) {
22901
105
          if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22902
105
        }
22903
22904
105
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22905
105
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22906
105
      }
22907
22908
7
      if (opline->extended_value == IS_ARRAY) {
22909
7
        zend_cast_zval_to_array(result, expr, IS_VAR);
22910
7
      } else {
22911
0
        ZEND_ASSERT(opline->extended_value == IS_OBJECT);
22912
0
        zend_cast_zval_to_object(result, expr, IS_VAR);
22913
0
      }
22914
6.16k
  }
22915
22916
6.06k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22917
6.06k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22918
6.06k
}
22919
22920
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22921
762
{
22922
762
  USE_OPLINE
22923
762
  zval *array_ptr, *result;
22924
22925
762
  SAVE_OPLINE();
22926
22927
762
  array_ptr = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22928
762
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22929
315
    result = EX_VAR(opline->result.var);
22930
315
    ZVAL_COPY_VALUE(result, array_ptr);
22931
315
    if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
22932
305
      Z_ADDREF_P(array_ptr);
22933
305
    }
22934
315
    Z_FE_POS_P(result) = 0;
22935
22936
315
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22937
315
    ZEND_VM_NEXT_OPCODE();
22938
447
  } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22939
447
    zend_object *zobj = Z_OBJ_P(array_ptr);
22940
447
    if (!zobj->ce->get_iterator) {
22941
24
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
22942
0
        zobj = zend_lazy_object_init(zobj);
22943
0
        if (UNEXPECTED(EG(exception))) {
22944
0
          UNDEF_RESULT();
22945
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22946
0
          HANDLE_EXCEPTION();
22947
0
        }
22948
0
      }
22949
24
      HashTable *properties = zobj->properties;
22950
24
      if (properties) {
22951
0
        if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
22952
0
          if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
22953
0
            GC_DELREF(properties);
22954
0
          }
22955
0
          properties = zobj->properties = zend_array_dup(properties);
22956
0
        }
22957
24
      } else {
22958
24
        properties = zobj->handlers->get_properties(zobj);
22959
24
      }
22960
22961
24
      result = EX_VAR(opline->result.var);
22962
24
      ZVAL_COPY_VALUE(result, array_ptr);
22963
24
      if (IS_VAR != IS_TMP_VAR) {
22964
24
        Z_ADDREF_P(array_ptr);
22965
24
      }
22966
22967
24
      if (zend_hash_num_elements(properties) == 0) {
22968
0
        Z_FE_ITER_P(result) = (uint32_t) -1;
22969
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22970
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22971
0
      }
22972
22973
24
      Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
22974
24
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22975
24
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22976
423
    } else {
22977
423
      bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
22978
22979
423
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22980
423
      if (UNEXPECTED(EG(exception))) {
22981
82
        HANDLE_EXCEPTION();
22982
341
      } else if (is_empty) {
22983
8
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22984
333
      } else {
22985
333
        ZEND_VM_NEXT_OPCODE();
22986
333
      }
22987
423
    }
22988
447
  } else {
22989
0
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22990
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
22991
0
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22992
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22993
0
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22994
0
  }
22995
762
}
22996
22997
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22998
76
{
22999
76
  USE_OPLINE
23000
76
  zval *array_ptr, *array_ref;
23001
23002
76
  SAVE_OPLINE();
23003
23004
76
  if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
23005
76
    array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23006
76
    if (Z_ISREF_P(array_ref)) {
23007
12
      array_ptr = Z_REFVAL_P(array_ref);
23008
12
    }
23009
76
  } else {
23010
0
    array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23011
0
  }
23012
23013
76
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
23014
33
    if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
23015
33
      if (array_ptr == array_ref) {
23016
21
        ZVAL_NEW_REF(array_ref, array_ref);
23017
21
        array_ptr = Z_REFVAL_P(array_ref);
23018
21
      }
23019
33
      Z_ADDREF_P(array_ref);
23020
33
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
23021
33
    } else {
23022
0
      array_ref = EX_VAR(opline->result.var);
23023
0
      ZVAL_NEW_REF(array_ref, array_ptr);
23024
0
      array_ptr = Z_REFVAL_P(array_ref);
23025
0
    }
23026
33
    if (IS_VAR == IS_CONST) {
23027
0
      ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
23028
33
    } else {
23029
33
      SEPARATE_ARRAY(array_ptr);
23030
33
    }
23031
33
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
23032
23033
33
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23034
33
    ZEND_VM_NEXT_OPCODE();
23035
43
  } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
23036
38
    if (!Z_OBJCE_P(array_ptr)->get_iterator) {
23037
12
      zend_object *zobj = Z_OBJ_P(array_ptr);
23038
12
      HashTable *properties;
23039
12
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
23040
0
        zobj = zend_lazy_object_init(zobj);
23041
0
        if (UNEXPECTED(EG(exception))) {
23042
0
          UNDEF_RESULT();
23043
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23044
0
          HANDLE_EXCEPTION();
23045
0
        }
23046
0
      }
23047
12
      if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
23048
12
        if (array_ptr == array_ref) {
23049
12
          ZVAL_NEW_REF(array_ref, array_ref);
23050
12
          array_ptr = Z_REFVAL_P(array_ref);
23051
12
        }
23052
12
        Z_ADDREF_P(array_ref);
23053
12
        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
23054
12
      } else {
23055
0
        array_ptr = EX_VAR(opline->result.var);
23056
0
        ZVAL_COPY_VALUE(array_ptr, array_ref);
23057
0
      }
23058
12
      if (Z_OBJ_P(array_ptr)->properties
23059
12
       && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
23060
0
        if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
23061
0
          GC_DELREF(Z_OBJ_P(array_ptr)->properties);
23062
0
        }
23063
0
        Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
23064
0
      }
23065
23066
12
      properties = Z_OBJPROP_P(array_ptr);
23067
12
      if (zend_hash_num_elements(properties) == 0) {
23068
0
        Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
23069
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23070
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
23071
0
      }
23072
23073
12
      Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
23074
12
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23075
12
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23076
26
    } else {
23077
26
      bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
23078
26
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23079
26
      if (UNEXPECTED(EG(exception))) {
23080
0
        HANDLE_EXCEPTION();
23081
26
      } else if (is_empty) {
23082
0
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23083
26
      } else {
23084
26
        ZEND_VM_NEXT_OPCODE();
23085
26
      }
23086
26
    }
23087
38
  } else {
23088
5
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
23089
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
23090
5
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
23091
5
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23092
5
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
23093
5
  }
23094
76
}
23095
23096
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23097
281k
{
23098
281k
  USE_OPLINE
23099
281k
  zval *array;
23100
281k
  zval *value;
23101
281k
  uint32_t value_type;
23102
281k
  HashTable *fe_ht;
23103
281k
  HashPosition pos;
23104
23105
281k
  array = EX_VAR(opline->op1.var);
23106
281k
  if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) {
23107
3.98k
    ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23108
3.98k
  }
23109
277k
  fe_ht = Z_ARRVAL_P(array);
23110
277k
  pos = Z_FE_POS_P(array);
23111
277k
  if (HT_IS_PACKED(fe_ht)) {
23112
265k
    value = fe_ht->arPacked + pos;
23113
265k
    while (1) {
23114
265k
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23115
        /* reached end of iteration */
23116
8.95k
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23117
8.95k
        ZEND_VM_CONTINUE();
23118
8.95k
      }
23119
256k
      value_type = Z_TYPE_INFO_P(value);
23120
256k
      ZEND_ASSERT(value_type != IS_INDIRECT);
23121
256k
      if (EXPECTED(value_type != IS_UNDEF)) {
23122
256k
        break;
23123
256k
      }
23124
70
      pos++;
23125
70
      value++;
23126
70
    }
23127
256k
    Z_FE_POS_P(array) = pos + 1;
23128
256k
    if (RETURN_VALUE_USED(opline)) {
23129
268
      ZVAL_LONG(EX_VAR(opline->result.var), pos);
23130
268
    }
23131
256k
  } else {
23132
11.6k
    Bucket *p;
23133
23134
11.6k
    p = fe_ht->arData + pos;
23135
11.7k
    while (1) {
23136
11.7k
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23137
        /* reached end of iteration */
23138
845
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23139
845
        ZEND_VM_CONTINUE();
23140
845
      }
23141
10.8k
      pos++;
23142
10.8k
      value = &p->val;
23143
10.8k
      value_type = Z_TYPE_INFO_P(value);
23144
10.8k
      ZEND_ASSERT(value_type != IS_INDIRECT);
23145
10.8k
      if (EXPECTED(value_type != IS_UNDEF)) {
23146
10.8k
        break;
23147
10.8k
      }
23148
15
      p++;
23149
15
    }
23150
10.8k
    Z_FE_POS_P(array) = pos;
23151
10.8k
    if (RETURN_VALUE_USED(opline)) {
23152
903
      if (!p->key) {
23153
101
        ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23154
802
      } else {
23155
802
        ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23156
802
      }
23157
903
    }
23158
10.8k
  }
23159
267k
  if (EXPECTED(opline->op2_type == IS_CV)) {
23160
266k
    zval *variable_ptr = EX_VAR(opline->op2.var);
23161
266k
    SAVE_OPLINE();
23162
266k
    zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
23163
266k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23164
266k
  } else {
23165
1.16k
    zval *res = EX_VAR(opline->op2.var);
23166
1.16k
    zend_refcounted *gc = Z_COUNTED_P(value);
23167
23168
1.16k
    ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
23169
1.16k
    if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
23170
174
      GC_ADDREF(gc);
23171
174
    }
23172
1.16k
    ZEND_VM_NEXT_OPCODE();
23173
1.16k
  }
23174
267k
}
23175
23176
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23177
6.28k
{
23178
6.28k
  USE_OPLINE
23179
6.28k
  zval *array;
23180
6.28k
  zval *value;
23181
6.28k
  uint32_t value_type;
23182
6.28k
  HashTable *fe_ht;
23183
6.28k
  HashPosition pos;
23184
6.28k
  Bucket *p;
23185
23186
6.28k
  array = EX_VAR(opline->op1.var);
23187
6.28k
  SAVE_OPLINE();
23188
23189
6.28k
  ZVAL_DEREF(array);
23190
6.28k
  if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
23191
5.41k
    pos = zend_hash_iterator_pos_ex(Z_FE_ITER_P(EX_VAR(opline->op1.var)), array);
23192
5.41k
    fe_ht = Z_ARRVAL_P(array);
23193
5.41k
    if (HT_IS_PACKED(fe_ht)) {
23194
4.37k
      value = fe_ht->arPacked + pos;
23195
4.76k
      while (1) {
23196
4.76k
        if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23197
          /* reached end of iteration */
23198
706
          goto fe_fetch_w_exit;
23199
706
        }
23200
4.06k
        value_type = Z_TYPE_INFO_P(value);
23201
4.06k
        ZEND_ASSERT(value_type != IS_INDIRECT);
23202
4.06k
        if (EXPECTED(value_type != IS_UNDEF)) {
23203
3.67k
          break;
23204
3.67k
        }
23205
392
        pos++;
23206
392
        value++;
23207
392
      }
23208
3.67k
      EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1;
23209
3.67k
      if (RETURN_VALUE_USED(opline)) {
23210
287
        ZVAL_LONG(EX_VAR(opline->result.var), pos);
23211
287
      }
23212
3.67k
    } else {
23213
1.04k
      p = fe_ht->arData + pos;
23214
1.05k
      while (1) {
23215
1.05k
        if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23216
          /* reached end of iteration */
23217
130
          goto fe_fetch_w_exit;
23218
130
        }
23219
922
        pos++;
23220
922
        value = &p->val;
23221
922
        value_type = Z_TYPE_INFO_P(value);
23222
922
        ZEND_ASSERT(value_type != IS_INDIRECT);
23223
922
        if (EXPECTED(value_type != IS_UNDEF)) {
23224
912
          break;
23225
912
        }
23226
10
        p++;
23227
10
      }
23228
912
      EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
23229
912
      if (RETURN_VALUE_USED(opline)) {
23230
619
        if (!p->key) {
23231
537
          ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23232
537
        } else {
23233
82
          ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23234
82
        }
23235
619
      }
23236
912
    }
23237
5.41k
  } else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
23238
859
    zend_object_iterator *iter;
23239
23240
859
    if ((iter = zend_iterator_unwrap(array)) == NULL) {
23241
      /* plain object */
23242
23243
176
      fe_ht = Z_OBJPROP_P(array);
23244
176
      pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
23245
176
      p = fe_ht->arData + pos;
23246
200
      while (1) {
23247
200
        if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23248
          /* reached end of iteration */
23249
55
          goto fe_fetch_w_exit;
23250
55
        }
23251
145
        pos++;
23252
145
        value = &p->val;
23253
145
        value_type = Z_TYPE_INFO_P(value);
23254
145
        if (EXPECTED(value_type != IS_UNDEF)) {
23255
145
          if (UNEXPECTED(value_type == IS_INDIRECT)) {
23256
136
            value = Z_INDIRECT_P(value);
23257
136
            value_type = Z_TYPE_INFO_P(value);
23258
136
            if (EXPECTED(value_type != IS_UNDEF)
23259
136
             && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
23260
112
              if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
23261
98
                zend_property_info *prop_info =
23262
98
                  zend_get_property_info_for_slot(Z_OBJ_P(array), value);
23263
98
                if (prop_info) {
23264
98
                  if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) {
23265
5
                    zend_throw_error(NULL,
23266
5
                      "Cannot acquire reference to readonly property %s::$%s",
23267
5
                      ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(p->key));
23268
5
                    UNDEF_RESULT();
23269
5
                    HANDLE_EXCEPTION();
23270
5
                  }
23271
93
                  if (ZEND_TYPE_IS_SET(prop_info->type)) {
23272
88
                    ZVAL_NEW_REF(value, value);
23273
88
                    ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
23274
88
                    value_type = IS_REFERENCE_EX;
23275
88
                  }
23276
93
                }
23277
98
              }
23278
107
              break;
23279
112
            }
23280
136
          } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
23281
9
              || !p->key
23282
9
              || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
23283
9
            break;
23284
9
          }
23285
145
        }
23286
24
        p++;
23287
24
      }
23288
116
      EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
23289
116
      if (RETURN_VALUE_USED(opline)) {
23290
106
        if (UNEXPECTED(!p->key)) {
23291
0
          ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23292
106
        } else if (ZSTR_VAL(p->key)[0]) {
23293
99
          ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23294
99
        } else {
23295
7
          const char *class_name, *prop_name;
23296
7
          size_t prop_name_len;
23297
7
          zend_unmangle_property_name_ex(
23298
7
            p->key, &class_name, &prop_name, &prop_name_len);
23299
7
          ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
23300
7
        }
23301
106
      }
23302
683
    } else {
23303
683
      const zend_object_iterator_funcs *funcs = iter->funcs;
23304
683
      if (++iter->index > 0) {
23305
        /* This could cause an endless loop if index becomes zero again.
23306
         * In case that ever happens we need an additional flag. */
23307
475
        funcs->move_forward(iter);
23308
475
        if (UNEXPECTED(EG(exception) != NULL)) {
23309
4
          UNDEF_RESULT();
23310
4
          HANDLE_EXCEPTION();
23311
4
        }
23312
471
        if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
23313
          /* reached end of iteration */
23314
190
          if (UNEXPECTED(EG(exception) != NULL)) {
23315
5
            UNDEF_RESULT();
23316
5
            HANDLE_EXCEPTION();
23317
5
          }
23318
185
          goto fe_fetch_w_exit;
23319
190
        }
23320
471
      }
23321
489
      value = funcs->get_current_data(iter);
23322
489
      if (UNEXPECTED(EG(exception) != NULL)) {
23323
5
        UNDEF_RESULT();
23324
5
        HANDLE_EXCEPTION();
23325
5
      }
23326
484
      if (!value) {
23327
        /* failure in get_current_data */
23328
0
        goto fe_fetch_w_exit;
23329
0
      }
23330
484
      if (RETURN_VALUE_USED(opline)) {
23331
345
        if (funcs->get_current_key) {
23332
345
          funcs->get_current_key(iter, EX_VAR(opline->result.var));
23333
345
          if (UNEXPECTED(EG(exception) != NULL)) {
23334
0
            UNDEF_RESULT();
23335
0
            HANDLE_EXCEPTION();
23336
0
          }
23337
345
        } else {
23338
0
          ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
23339
0
        }
23340
345
      }
23341
484
      value_type = Z_TYPE_INFO_P(value);
23342
484
    }
23343
859
  } else {
23344
5
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array));
23345
5
    if (UNEXPECTED(EG(exception))) {
23346
0
      UNDEF_RESULT();
23347
0
      HANDLE_EXCEPTION();
23348
0
    }
23349
1.08k
fe_fetch_w_exit:
23350
1.08k
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23351
1.08k
    ZEND_VM_CONTINUE();
23352
1.08k
  }
23353
23354
5.18k
  if (EXPECTED((value_type & Z_TYPE_MASK) != IS_REFERENCE)) {
23355
3.79k
    zend_refcounted *gc = Z_COUNTED_P(value);
23356
3.79k
    zval *ref;
23357
3.79k
    ZVAL_NEW_EMPTY_REF(value);
23358
3.79k
    ref = Z_REFVAL_P(value);
23359
3.79k
    ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
23360
3.79k
  }
23361
5.18k
  if (EXPECTED(opline->op2_type == IS_CV)) {
23362
5.16k
    zval *variable_ptr = EX_VAR(opline->op2.var);
23363
5.16k
    if (EXPECTED(variable_ptr != value)) {
23364
5.16k
      zend_reference *ref;
23365
23366
5.16k
      ref = Z_REF_P(value);
23367
5.16k
      GC_ADDREF(ref);
23368
5.16k
      i_zval_ptr_dtor(variable_ptr);
23369
5.16k
      ZVAL_REF(variable_ptr, ref);
23370
5.16k
    }
23371
5.16k
  } else {
23372
20
    Z_ADDREF_P(value);
23373
20
    ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value));
23374
20
  }
23375
5.18k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23376
5.18k
}
23377
23378
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23379
5
{
23380
5
  USE_OPLINE
23381
5
  zval *value;
23382
5
  zend_reference *ref = NULL;
23383
5
  bool ret;
23384
23385
5
  SAVE_OPLINE();
23386
5
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23387
23388
5
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) {
23389
5
    if (IS_VAR == IS_VAR) {
23390
5
      ref = Z_REF_P(value);
23391
5
    }
23392
5
    value = Z_REFVAL_P(value);
23393
5
  }
23394
23395
5
  ret = i_zend_is_true(value);
23396
23397
5
  if (UNEXPECTED(EG(exception))) {
23398
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23399
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
23400
0
    HANDLE_EXCEPTION();
23401
0
  }
23402
23403
5
  if (ret) {
23404
5
    zval *result = EX_VAR(opline->result.var);
23405
23406
5
    ZVAL_COPY_VALUE(result, value);
23407
5
    if (IS_VAR == IS_CONST) {
23408
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
23409
5
    } else if (IS_VAR == IS_CV) {
23410
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
23411
5
    } else if (IS_VAR == IS_VAR && ref) {
23412
5
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23413
5
        efree_size(ref, sizeof(zend_reference));
23414
5
      } else if (Z_OPT_REFCOUNTED_P(result)) {
23415
0
        Z_ADDREF_P(result);
23416
0
      }
23417
5
    }
23418
5
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23419
5
  }
23420
23421
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23422
0
  ZEND_VM_NEXT_OPCODE();
23423
0
}
23424
23425
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23426
118
{
23427
118
  USE_OPLINE
23428
118
  zval *value;
23429
118
  zend_reference *ref = NULL;
23430
23431
118
  SAVE_OPLINE();
23432
118
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23433
23434
118
  if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
23435
113
    if (IS_VAR & IS_VAR) {
23436
113
      ref = Z_REF_P(value);
23437
113
    }
23438
113
    value = Z_REFVAL_P(value);
23439
113
  }
23440
23441
118
  if (Z_TYPE_P(value) > IS_NULL) {
23442
107
    zval *result = EX_VAR(opline->result.var);
23443
107
    ZVAL_COPY_VALUE(result, value);
23444
107
    if (IS_VAR == IS_CONST) {
23445
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
23446
107
    } else if (IS_VAR == IS_CV) {
23447
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
23448
107
    } else if ((IS_VAR & IS_VAR) && ref) {
23449
102
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23450
5
        efree_size(ref, sizeof(zend_reference));
23451
97
      } else if (Z_OPT_REFCOUNTED_P(result)) {
23452
0
        Z_ADDREF_P(result);
23453
0
      }
23454
102
    }
23455
107
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23456
107
  }
23457
23458
11
  if ((IS_VAR & IS_VAR) && ref) {
23459
11
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23460
0
      efree_size(ref, sizeof(zend_reference));
23461
0
    }
23462
11
  }
23463
11
  ZEND_VM_NEXT_OPCODE();
23464
11
}
23465
23466
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23467
149
{
23468
149
  USE_OPLINE
23469
149
  zval *val, *result;
23470
23471
149
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23472
23473
149
  if (Z_TYPE_P(val) > IS_NULL) {
23474
29
    do {
23475
29
      if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
23476
5
        val = Z_REFVAL_P(val);
23477
5
        if (Z_TYPE_P(val) <= IS_NULL) {
23478
5
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23479
5
          break;
23480
5
        }
23481
5
      }
23482
24
      ZEND_VM_NEXT_OPCODE();
23483
24
    } while (0);
23484
29
  }
23485
23486
125
  result = EX_VAR(opline->result.var);
23487
125
  uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
23488
125
  if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
23489
125
    ZVAL_NULL(result);
23490
125
    if (IS_VAR == IS_CV
23491
125
      && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
23492
125
      && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
23493
125
    ) {
23494
0
      SAVE_OPLINE();
23495
0
      ZVAL_UNDEFINED_OP1();
23496
0
      if (UNEXPECTED(EG(exception) != NULL)) {
23497
0
        HANDLE_EXCEPTION();
23498
0
      }
23499
0
    }
23500
125
  } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
23501
0
    ZVAL_FALSE(result);
23502
0
  } else {
23503
0
    ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
23504
0
    ZVAL_TRUE(result);
23505
0
  }
23506
23507
125
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23508
125
}
23509
23510
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23511
4.18k
{
23512
4.18k
  USE_OPLINE
23513
4.18k
  zval *value;
23514
4.18k
  zval *result = EX_VAR(opline->result.var);
23515
23516
4.18k
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23517
4.18k
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
23518
0
    SAVE_OPLINE();
23519
0
    ZVAL_UNDEFINED_OP1();
23520
0
    ZVAL_NULL(result);
23521
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23522
0
  }
23523
23524
4.18k
  if (IS_VAR == IS_CV) {
23525
0
    ZVAL_COPY_DEREF(result, value);
23526
4.18k
  } else if (IS_VAR == IS_VAR) {
23527
4.18k
    if (UNEXPECTED(Z_ISREF_P(value))) {
23528
23
      ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
23529
23
      if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
23530
5
        efree_size(Z_REF_P(value), sizeof(zend_reference));
23531
18
      } else if (Z_OPT_REFCOUNTED_P(result)) {
23532
0
        Z_ADDREF_P(result);
23533
0
      }
23534
4.16k
    } else {
23535
4.16k
      ZVAL_COPY_VALUE(result, value);
23536
4.16k
    }
23537
4.18k
  } else {
23538
0
    ZVAL_COPY_VALUE(result, value);
23539
0
    if (IS_VAR == IS_CONST) {
23540
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
23541
0
        Z_ADDREF_P(result);
23542
0
      }
23543
0
    }
23544
0
  }
23545
4.18k
  ZEND_VM_NEXT_OPCODE();
23546
4.18k
}
23547
23548
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23549
13.4k
{
23550
13.4k
  USE_OPLINE
23551
13.4k
  zval *varptr, *arg;
23552
23553
13.4k
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23554
13.4k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
23555
23556
13.4k
  if (IS_VAR == IS_CV) {
23557
0
    ZVAL_COPY(arg, varptr);
23558
13.4k
  } else /* if (IS_VAR == IS_VAR) */ {
23559
13.4k
    ZVAL_COPY_VALUE(arg, varptr);
23560
13.4k
  }
23561
23562
13.4k
  ZEND_VM_NEXT_OPCODE();
23563
13.4k
}
23564
23565
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23566
520
{
23567
520
  USE_OPLINE
23568
520
  zval *op1, *op2;
23569
520
  bool result;
23570
23571
520
  SAVE_OPLINE();
23572
520
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23573
520
  op2 = RT_CONSTANT(opline, opline->op2);
23574
520
  result = fast_is_identical_function(op1, op2);
23575
520
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23576
23577
520
  ZEND_VM_SMART_BRANCH(result, 1);
23578
520
}
23579
23580
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23581
0
{
23582
0
  USE_OPLINE
23583
0
  zval *op1, *op2;
23584
0
  bool result;
23585
23586
0
  SAVE_OPLINE();
23587
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23588
0
  op2 = RT_CONSTANT(opline, opline->op2);
23589
0
  result = fast_is_identical_function(op1, op2);
23590
23591
0
  ZEND_VM_SMART_BRANCH(result, 1);
23592
0
}
23593
23594
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23595
45
{
23596
45
  USE_OPLINE
23597
45
  zval *op1, *op2;
23598
45
  bool result;
23599
23600
45
  SAVE_OPLINE();
23601
45
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23602
45
  op2 = RT_CONSTANT(opline, opline->op2);
23603
45
  result = fast_is_not_identical_function(op1, op2);
23604
45
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23605
23606
45
  ZEND_VM_SMART_BRANCH(result, 1);
23607
45
}
23608
23609
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23610
38
{
23611
38
  USE_OPLINE
23612
38
  zval *object;
23613
38
  zval *property;
23614
38
  zval *value;
23615
38
  zval *zptr;
23616
38
  void *_cache_slot[3] = {0};
23617
38
  void **cache_slot;
23618
38
  zend_property_info *prop_info;
23619
38
  zend_object *zobj;
23620
38
  zend_string *name, *tmp_name;
23621
23622
38
  SAVE_OPLINE();
23623
38
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23624
38
  property = RT_CONSTANT(opline, opline->op2);
23625
23626
38
  do {
23627
38
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23628
23629
38
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23630
10
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23631
0
        object = Z_REFVAL_P(object);
23632
0
        goto assign_op_object;
23633
0
      }
23634
10
      if (IS_VAR == IS_CV
23635
10
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23636
0
        ZVAL_UNDEFINED_OP1();
23637
0
      }
23638
10
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23639
10
      break;
23640
10
    }
23641
23642
28
assign_op_object:
23643
    /* here we are sure we are dealing with an object */
23644
28
    zobj = Z_OBJ_P(object);
23645
28
    if (IS_CONST == IS_CONST) {
23646
28
      name = Z_STR_P(property);
23647
28
    } else {
23648
0
      name = zval_try_get_tmp_string(property, &tmp_name);
23649
0
      if (UNEXPECTED(!name)) {
23650
0
        UNDEF_RESULT();
23651
0
        break;
23652
0
      }
23653
0
    }
23654
28
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
23655
28
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23656
28
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23657
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23658
0
          ZVAL_NULL(EX_VAR(opline->result.var));
23659
0
        }
23660
28
      } else {
23661
28
        zend_reference *ref;
23662
23663
28
        do {
23664
28
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
23665
0
            ref = Z_REF_P(zptr);
23666
0
            zptr = Z_REFVAL_P(zptr);
23667
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23668
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23669
0
              break;
23670
0
            }
23671
0
          }
23672
23673
28
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23674
28
          if (prop_info) {
23675
            /* special case for typed properties */
23676
12
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
23677
16
          } else {
23678
16
            zend_binary_op(zptr, zptr, value OPLINE_CC);
23679
16
          }
23680
28
        } while (0);
23681
23682
28
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23683
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
23684
0
        }
23685
28
      }
23686
28
    } else {
23687
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
23688
0
    }
23689
28
    if (IS_CONST != IS_CONST) {
23690
0
      zend_tmp_string_release(tmp_name);
23691
0
    }
23692
28
  } while (0);
23693
23694
38
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23695
23696
38
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23697
  /* assign_obj has two opcodes! */
23698
38
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
23699
38
}
23700
23701
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
23702
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23703
332
{
23704
332
  USE_OPLINE
23705
332
  zval *var_ptr;
23706
332
  zval *value, *container, *dim;
23707
332
  HashTable *ht;
23708
23709
332
  SAVE_OPLINE();
23710
332
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23711
23712
332
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23713
178
assign_dim_op_array:
23714
178
    SEPARATE_ARRAY(container);
23715
178
    ht = Z_ARRVAL_P(container);
23716
332
assign_dim_op_new_array:
23717
332
    dim = RT_CONSTANT(opline, opline->op2);
23718
332
    if (IS_CONST == IS_UNUSED) {
23719
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
23720
0
      if (UNEXPECTED(!var_ptr)) {
23721
0
        zend_cannot_add_element();
23722
0
        goto assign_dim_op_ret_null;
23723
0
      }
23724
332
    } else {
23725
332
      if (IS_CONST == IS_CONST) {
23726
332
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
23727
332
      } else {
23728
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
23729
0
      }
23730
332
      if (UNEXPECTED(!var_ptr)) {
23731
0
        goto assign_dim_op_ret_null;
23732
0
      }
23733
332
    }
23734
23735
332
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23736
23737
332
    do {
23738
332
      if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
23739
0
        zend_reference *ref = Z_REF_P(var_ptr);
23740
0
        var_ptr = Z_REFVAL_P(var_ptr);
23741
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23742
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23743
0
          break;
23744
0
        }
23745
0
      }
23746
332
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23747
332
    } while (0);
23748
23749
332
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23750
59
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23751
59
    }
23752
332
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23753
332
  } else {
23754
154
    if (EXPECTED(Z_ISREF_P(container))) {
23755
0
      container = Z_REFVAL_P(container);
23756
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23757
0
        goto assign_dim_op_array;
23758
0
      }
23759
0
    }
23760
23761
154
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
23762
0
      zend_object *obj = Z_OBJ_P(container);
23763
23764
0
      dim = RT_CONSTANT(opline, opline->op2);
23765
0
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
23766
0
        dim++;
23767
0
      }
23768
0
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
23769
154
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
23770
154
      uint8_t old_type;
23771
23772
154
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
23773
0
        ZVAL_UNDEFINED_OP1();
23774
0
      }
23775
154
      ht = zend_new_array(8);
23776
154
      old_type = Z_TYPE_P(container);
23777
154
      ZVAL_ARR(container, ht);
23778
154
      if (UNEXPECTED(old_type == IS_FALSE)) {
23779
0
        GC_ADDREF(ht);
23780
0
        zend_false_to_array_deprecated();
23781
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
23782
0
          zend_array_destroy(ht);
23783
0
          goto assign_dim_op_ret_null;
23784
0
        }
23785
0
      }
23786
154
      goto assign_dim_op_new_array;
23787
154
    } else {
23788
0
      dim = RT_CONSTANT(opline, opline->op2);
23789
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
23790
0
assign_dim_op_ret_null:
23791
0
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23792
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23793
0
        ZVAL_NULL(EX_VAR(opline->result.var));
23794
0
      }
23795
0
    }
23796
154
  }
23797
23798
332
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23799
332
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
23800
332
}
23801
23802
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23803
16
{
23804
16
  USE_OPLINE
23805
16
  zval *var_ptr;
23806
16
  zval *value;
23807
23808
16
  SAVE_OPLINE();
23809
16
  value = RT_CONSTANT(opline, opline->op2);
23810
16
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23811
23812
16
  do {
23813
16
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
23814
0
      zend_reference *ref = Z_REF_P(var_ptr);
23815
0
      var_ptr = Z_REFVAL_P(var_ptr);
23816
0
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23817
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23818
0
        break;
23819
0
      }
23820
0
    }
23821
16
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23822
16
  } while (0);
23823
23824
16
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23825
0
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23826
0
  }
23827
23828
16
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23829
16
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23830
16
}
23831
23832
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23833
37
{
23834
37
  USE_OPLINE
23835
37
  zval *object;
23836
37
  zval *property;
23837
37
  zval *zptr;
23838
37
  void *_cache_slot[3] = {0};
23839
37
  void **cache_slot;
23840
37
  zend_property_info *prop_info;
23841
37
  zend_object *zobj;
23842
37
  zend_string *name, *tmp_name;
23843
23844
37
  SAVE_OPLINE();
23845
37
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23846
37
  property = RT_CONSTANT(opline, opline->op2);
23847
23848
37
  do {
23849
37
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23850
32
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23851
0
        object = Z_REFVAL_P(object);
23852
0
        goto pre_incdec_object;
23853
0
      }
23854
32
      if (IS_VAR == IS_CV
23855
32
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23856
0
        ZVAL_UNDEFINED_OP1();
23857
0
      }
23858
32
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23859
32
      break;
23860
32
    }
23861
23862
5
pre_incdec_object:
23863
    /* here we are sure we are dealing with an object */
23864
5
    zobj = Z_OBJ_P(object);
23865
5
    if (IS_CONST == IS_CONST) {
23866
5
      name = Z_STR_P(property);
23867
5
    } else {
23868
0
      name = zval_try_get_tmp_string(property, &tmp_name);
23869
0
      if (UNEXPECTED(!name)) {
23870
0
        UNDEF_RESULT();
23871
0
        break;
23872
0
      }
23873
0
    }
23874
5
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
23875
5
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23876
5
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23877
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23878
0
          ZVAL_NULL(EX_VAR(opline->result.var));
23879
0
        }
23880
5
      } else {
23881
5
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
23882
5
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23883
5
      }
23884
5
    } else {
23885
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23886
0
    }
23887
5
    if (IS_CONST != IS_CONST) {
23888
0
      zend_tmp_string_release(tmp_name);
23889
0
    }
23890
5
  } while (0);
23891
23892
37
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23893
37
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23894
37
}
23895
23896
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23897
0
{
23898
0
  USE_OPLINE
23899
0
  zval *object;
23900
0
  zval *property;
23901
0
  zval *zptr;
23902
0
  void *_cache_slot[3] = {0};
23903
0
  void **cache_slot;
23904
0
  zend_property_info *prop_info;
23905
0
  zend_object *zobj;
23906
0
  zend_string *name, *tmp_name;
23907
23908
0
  SAVE_OPLINE();
23909
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23910
0
  property = RT_CONSTANT(opline, opline->op2);
23911
23912
0
  do {
23913
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23914
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23915
0
        object = Z_REFVAL_P(object);
23916
0
        goto post_incdec_object;
23917
0
      }
23918
0
      if (IS_VAR == IS_CV
23919
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23920
0
        ZVAL_UNDEFINED_OP1();
23921
0
      }
23922
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23923
0
      break;
23924
0
    }
23925
23926
0
post_incdec_object:
23927
    /* here we are sure we are dealing with an object */
23928
0
    zobj = Z_OBJ_P(object);
23929
0
    if (IS_CONST == IS_CONST) {
23930
0
      name = Z_STR_P(property);
23931
0
    } else {
23932
0
      name = zval_try_get_tmp_string(property, &tmp_name);
23933
0
      if (UNEXPECTED(!name)) {
23934
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
23935
0
        break;
23936
0
      }
23937
0
    }
23938
0
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
23939
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23940
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23941
0
        ZVAL_NULL(EX_VAR(opline->result.var));
23942
0
      } else {
23943
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23944
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23945
0
      }
23946
0
    } else {
23947
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23948
0
    }
23949
0
    if (IS_CONST != IS_CONST) {
23950
0
      zend_tmp_string_release(tmp_name);
23951
0
    }
23952
0
  } while (0);
23953
23954
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23955
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23956
0
}
23957
23958
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23959
1.44k
{
23960
1.44k
  USE_OPLINE
23961
1.44k
  zval *container;
23962
23963
1.44k
  SAVE_OPLINE();
23964
1.44k
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23965
1.44k
  zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23966
23967
1.44k
  if (IS_VAR == IS_VAR) {
23968
1.44k
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23969
1.44k
  }
23970
1.44k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23971
1.44k
}
23972
23973
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23974
248
{
23975
248
  USE_OPLINE
23976
248
  zval *container;
23977
23978
248
  SAVE_OPLINE();
23979
248
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23980
248
  zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23981
23982
248
  if (IS_VAR == IS_VAR) {
23983
248
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23984
248
  }
23985
248
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23986
248
}
23987
23988
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23989
35
{
23990
#if 0
23991
  USE_OPLINE
23992
#endif
23993
23994
35
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23995
18
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23996
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23997
0
    }
23998
18
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23999
18
  } else {
24000
17
    if (IS_CONST == IS_UNUSED) {
24001
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24002
0
    }
24003
17
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24004
17
  }
24005
35
}
24006
24007
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24008
5
{
24009
5
  USE_OPLINE
24010
5
  zval *container;
24011
24012
5
  SAVE_OPLINE();
24013
5
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24014
5
  zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
24015
24016
5
  if (IS_VAR == IS_VAR) {
24017
5
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
24018
5
  }
24019
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24020
5
}
24021
24022
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24023
137
{
24024
137
  USE_OPLINE
24025
137
  zval *property, *container, *result;
24026
24027
137
  SAVE_OPLINE();
24028
24029
137
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24030
137
  property = RT_CONSTANT(opline, opline->op2);
24031
137
  result = EX_VAR(opline->result.var);
24032
137
  zend_fetch_property_address(
24033
137
    result, container, IS_VAR, property, IS_CONST,
24034
137
    ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
24035
137
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
24036
24037
137
  if (IS_VAR == IS_VAR) {
24038
137
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
24039
137
  }
24040
137
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24041
137
}
24042
24043
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24044
21
{
24045
21
  USE_OPLINE
24046
21
  zval *property, *container, *result;
24047
24048
21
  SAVE_OPLINE();
24049
21
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24050
21
  property = RT_CONSTANT(opline, opline->op2);
24051
21
  result = EX_VAR(opline->result.var);
24052
21
  zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
24053
24054
21
  if (IS_VAR == IS_VAR) {
24055
21
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
24056
21
  }
24057
21
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24058
21
}
24059
24060
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24061
27
{
24062
#if 0
24063
  USE_OPLINE
24064
#endif
24065
24066
27
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
24067
    /* Behave like FETCH_OBJ_W */
24068
12
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
24069
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24070
0
    }
24071
12
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24072
15
  } else {
24073
15
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24074
15
  }
24075
27
}
24076
24077
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24078
43
{
24079
43
  USE_OPLINE
24080
43
  zval *container, *property, *result;
24081
24082
43
  SAVE_OPLINE();
24083
43
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24084
43
  property = RT_CONSTANT(opline, opline->op2);
24085
43
  result = EX_VAR(opline->result.var);
24086
43
  zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
24087
24088
43
  if (IS_VAR == IS_VAR) {
24089
43
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
24090
43
  }
24091
43
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24092
43
}
24093
24094
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24095
409
{
24096
409
  USE_OPLINE
24097
409
  zval *container, *dim;
24098
24099
409
  SAVE_OPLINE();
24100
409
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24101
409
  dim = RT_CONSTANT(opline, opline->op2);
24102
24103
409
  if (IS_VAR == IS_VAR
24104
409
    && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
24105
409
    && UNEXPECTED(!Z_ISREF_P(container))
24106
409
  ) {
24107
15
    zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
24108
15
    zend_fetch_dimension_address_LIST_r(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
24109
394
  } else {
24110
394
    zend_fetch_dimension_address_W(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
24111
394
  }
24112
24113
409
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24114
409
}
24115
24116
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24117
402
{
24118
402
  USE_OPLINE
24119
402
  zval *object, *value, tmp;
24120
402
  zend_object *zobj;
24121
402
  zend_string *name, *tmp_name;
24122
402
  zend_refcounted *garbage = NULL;
24123
24124
402
  SAVE_OPLINE();
24125
402
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24126
402
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
24127
24128
402
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24129
85
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24130
24
      object = Z_REFVAL_P(object);
24131
24
      goto assign_object;
24132
24
    }
24133
61
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24134
61
    value = &EG(uninitialized_zval);
24135
61
    goto free_and_exit_assign_obj;
24136
85
  }
24137
24138
341
assign_object:
24139
341
  zobj = Z_OBJ_P(object);
24140
341
  if (IS_CONST == IS_CONST) {
24141
341
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24142
87
      void **cache_slot = CACHE_ADDR(opline->extended_value);
24143
87
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24144
87
      zval *property_val;
24145
87
      zend_property_info *prop_info;
24146
24147
87
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24148
77
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24149
24150
77
assign_obj_simple:
24151
77
        property_val = OBJ_PROP(zobj, prop_offset);
24152
77
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
24153
70
          if (prop_info != NULL) {
24154
70
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24155
70
            goto free_and_exit_assign_obj;
24156
70
          } else {
24157
0
fast_assign_obj:
24158
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24159
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24160
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
24161
0
            }
24162
0
            goto exit_assign_obj;
24163
0
          }
24164
70
        }
24165
77
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24166
10
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24167
10
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24168
0
          zobj = zend_lazy_object_init(zobj);
24169
0
          if (!zobj) {
24170
0
            value = &EG(uninitialized_zval);
24171
0
            goto free_and_exit_assign_obj;
24172
0
          }
24173
0
        }
24174
10
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24175
10
          rebuild_object_properties_internal(zobj);
24176
10
        }
24177
10
        if (EXPECTED(zobj->properties != NULL)) {
24178
10
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24179
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24180
0
              GC_DELREF(zobj->properties);
24181
0
            }
24182
0
            zobj->properties = zend_array_dup(zobj->properties);
24183
0
          }
24184
10
          property_val = zend_hash_find_known_hash(zobj->properties, name);
24185
10
          if (property_val) {
24186
0
            goto fast_assign_obj;
24187
0
          }
24188
10
        }
24189
24190
10
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24191
10
          if (IS_CONST == IS_CONST) {
24192
10
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24193
0
              Z_ADDREF_P(value);
24194
0
            }
24195
10
          } else if (IS_CONST != IS_TMP_VAR) {
24196
0
            if (Z_ISREF_P(value)) {
24197
0
              if (IS_CONST == IS_VAR) {
24198
0
                zend_reference *ref = Z_REF_P(value);
24199
0
                if (GC_DELREF(ref) == 0) {
24200
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24201
0
                  efree_size(ref, sizeof(zend_reference));
24202
0
                  value = &tmp;
24203
0
                } else {
24204
0
                  value = Z_REFVAL_P(value);
24205
0
                  Z_TRY_ADDREF_P(value);
24206
0
                }
24207
0
              } else {
24208
0
                value = Z_REFVAL_P(value);
24209
0
                Z_TRY_ADDREF_P(value);
24210
0
              }
24211
0
            } else if (IS_CONST == IS_CV) {
24212
0
              Z_TRY_ADDREF_P(value);
24213
0
            }
24214
0
          }
24215
10
          zend_hash_add_new(zobj->properties, name, value);
24216
10
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24217
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
24218
0
          }
24219
10
          goto exit_assign_obj;
24220
10
        }
24221
10
      } else {
24222
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24223
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24224
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
24225
0
          prop_offset = prop_info->offset;
24226
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24227
0
            prop_info = NULL;
24228
0
          }
24229
0
          goto assign_obj_simple;
24230
0
        }
24231
        /* Fall through to write_property for hooks. */
24232
0
      }
24233
87
    }
24234
261
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24235
261
  } else {
24236
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24237
0
    if (UNEXPECTED(!name)) {
24238
24239
0
      UNDEF_RESULT();
24240
0
      goto exit_assign_obj;
24241
0
    }
24242
0
  }
24243
24244
261
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24245
0
    ZVAL_DEREF(value);
24246
0
  }
24247
24248
261
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24249
24250
261
  if (IS_CONST != IS_CONST) {
24251
0
    zend_tmp_string_release(tmp_name);
24252
0
  }
24253
24254
392
free_and_exit_assign_obj:
24255
392
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24256
50
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24257
50
  }
24258
24259
402
exit_assign_obj:
24260
402
  if (garbage) {
24261
0
    GC_DTOR_NO_REF(garbage);
24262
0
  }
24263
24264
402
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24265
  /* assign_obj has two opcodes! */
24266
402
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24267
402
}
24268
24269
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24270
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24271
262
{
24272
262
  USE_OPLINE
24273
262
  zval *object, *value, tmp;
24274
262
  zend_object *zobj;
24275
262
  zend_string *name, *tmp_name;
24276
262
  zend_refcounted *garbage = NULL;
24277
24278
262
  SAVE_OPLINE();
24279
262
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24280
262
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24281
24282
262
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24283
4
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24284
0
      object = Z_REFVAL_P(object);
24285
0
      goto assign_object;
24286
0
    }
24287
4
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24288
4
    value = &EG(uninitialized_zval);
24289
4
    goto free_and_exit_assign_obj;
24290
4
  }
24291
24292
258
assign_object:
24293
258
  zobj = Z_OBJ_P(object);
24294
258
  if (IS_CONST == IS_CONST) {
24295
258
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24296
155
      void **cache_slot = CACHE_ADDR(opline->extended_value);
24297
155
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24298
155
      zval *property_val;
24299
155
      zend_property_info *prop_info;
24300
24301
155
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24302
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24303
24304
0
assign_obj_simple:
24305
0
        property_val = OBJ_PROP(zobj, prop_offset);
24306
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
24307
0
          if (prop_info != NULL) {
24308
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24309
0
            goto free_and_exit_assign_obj;
24310
0
          } else {
24311
0
fast_assign_obj:
24312
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24313
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24314
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
24315
0
            }
24316
0
            goto exit_assign_obj;
24317
0
          }
24318
0
        }
24319
155
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24320
155
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24321
155
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24322
0
          zobj = zend_lazy_object_init(zobj);
24323
0
          if (!zobj) {
24324
0
            value = &EG(uninitialized_zval);
24325
0
            goto free_and_exit_assign_obj;
24326
0
          }
24327
0
        }
24328
155
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24329
150
          rebuild_object_properties_internal(zobj);
24330
150
        }
24331
155
        if (EXPECTED(zobj->properties != NULL)) {
24332
150
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24333
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24334
0
              GC_DELREF(zobj->properties);
24335
0
            }
24336
0
            zobj->properties = zend_array_dup(zobj->properties);
24337
0
          }
24338
150
          property_val = zend_hash_find_known_hash(zobj->properties, name);
24339
150
          if (property_val) {
24340
0
            goto fast_assign_obj;
24341
0
          }
24342
150
        }
24343
24344
155
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24345
150
          if (IS_TMP_VAR == IS_CONST) {
24346
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24347
0
              Z_ADDREF_P(value);
24348
0
            }
24349
150
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
24350
0
            if (Z_ISREF_P(value)) {
24351
0
              if (IS_TMP_VAR == IS_VAR) {
24352
0
                zend_reference *ref = Z_REF_P(value);
24353
0
                if (GC_DELREF(ref) == 0) {
24354
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24355
0
                  efree_size(ref, sizeof(zend_reference));
24356
0
                  value = &tmp;
24357
0
                } else {
24358
0
                  value = Z_REFVAL_P(value);
24359
0
                  Z_TRY_ADDREF_P(value);
24360
0
                }
24361
0
              } else {
24362
0
                value = Z_REFVAL_P(value);
24363
0
                Z_TRY_ADDREF_P(value);
24364
0
              }
24365
0
            } else if (IS_TMP_VAR == IS_CV) {
24366
0
              Z_TRY_ADDREF_P(value);
24367
0
            }
24368
0
          }
24369
150
          zend_hash_add_new(zobj->properties, name, value);
24370
150
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24371
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
24372
0
          }
24373
150
          goto exit_assign_obj;
24374
150
        }
24375
155
      } else {
24376
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24377
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24378
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
24379
0
          prop_offset = prop_info->offset;
24380
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24381
0
            prop_info = NULL;
24382
0
          }
24383
0
          goto assign_obj_simple;
24384
0
        }
24385
        /* Fall through to write_property for hooks. */
24386
0
      }
24387
155
    }
24388
108
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24389
108
  } else {
24390
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24391
0
    if (UNEXPECTED(!name)) {
24392
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24393
0
      UNDEF_RESULT();
24394
0
      goto exit_assign_obj;
24395
0
    }
24396
0
  }
24397
24398
108
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24399
0
    ZVAL_DEREF(value);
24400
0
  }
24401
24402
108
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24403
24404
108
  if (IS_CONST != IS_CONST) {
24405
0
    zend_tmp_string_release(tmp_name);
24406
0
  }
24407
24408
112
free_and_exit_assign_obj:
24409
112
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24410
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24411
0
  }
24412
112
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24413
262
exit_assign_obj:
24414
262
  if (garbage) {
24415
0
    GC_DTOR_NO_REF(garbage);
24416
0
  }
24417
24418
262
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24419
  /* assign_obj has two opcodes! */
24420
262
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24421
262
}
24422
24423
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24424
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24425
52
{
24426
52
  USE_OPLINE
24427
52
  zval *object, *value, tmp;
24428
52
  zend_object *zobj;
24429
52
  zend_string *name, *tmp_name;
24430
52
  zend_refcounted *garbage = NULL;
24431
24432
52
  SAVE_OPLINE();
24433
52
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24434
52
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24435
24436
52
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24437
21
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24438
13
      object = Z_REFVAL_P(object);
24439
13
      goto assign_object;
24440
13
    }
24441
8
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24442
8
    value = &EG(uninitialized_zval);
24443
8
    goto free_and_exit_assign_obj;
24444
21
  }
24445
24446
44
assign_object:
24447
44
  zobj = Z_OBJ_P(object);
24448
44
  if (IS_CONST == IS_CONST) {
24449
44
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24450
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
24451
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24452
0
      zval *property_val;
24453
0
      zend_property_info *prop_info;
24454
24455
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24456
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24457
24458
0
assign_obj_simple:
24459
0
        property_val = OBJ_PROP(zobj, prop_offset);
24460
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
24461
0
          if (prop_info != NULL) {
24462
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24463
0
            goto free_and_exit_assign_obj;
24464
0
          } else {
24465
0
fast_assign_obj:
24466
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
24467
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24468
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
24469
0
            }
24470
0
            goto exit_assign_obj;
24471
0
          }
24472
0
        }
24473
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24474
0
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24475
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24476
0
          zobj = zend_lazy_object_init(zobj);
24477
0
          if (!zobj) {
24478
0
            value = &EG(uninitialized_zval);
24479
0
            goto free_and_exit_assign_obj;
24480
0
          }
24481
0
        }
24482
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24483
0
          rebuild_object_properties_internal(zobj);
24484
0
        }
24485
0
        if (EXPECTED(zobj->properties != NULL)) {
24486
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24487
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24488
0
              GC_DELREF(zobj->properties);
24489
0
            }
24490
0
            zobj->properties = zend_array_dup(zobj->properties);
24491
0
          }
24492
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
24493
0
          if (property_val) {
24494
0
            goto fast_assign_obj;
24495
0
          }
24496
0
        }
24497
24498
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24499
0
          if (IS_VAR == IS_CONST) {
24500
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24501
0
              Z_ADDREF_P(value);
24502
0
            }
24503
0
          } else if (IS_VAR != IS_TMP_VAR) {
24504
0
            if (Z_ISREF_P(value)) {
24505
0
              if (IS_VAR == IS_VAR) {
24506
0
                zend_reference *ref = Z_REF_P(value);
24507
0
                if (GC_DELREF(ref) == 0) {
24508
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24509
0
                  efree_size(ref, sizeof(zend_reference));
24510
0
                  value = &tmp;
24511
0
                } else {
24512
0
                  value = Z_REFVAL_P(value);
24513
0
                  Z_TRY_ADDREF_P(value);
24514
0
                }
24515
0
              } else {
24516
0
                value = Z_REFVAL_P(value);
24517
0
                Z_TRY_ADDREF_P(value);
24518
0
              }
24519
0
            } else if (IS_VAR == IS_CV) {
24520
0
              Z_TRY_ADDREF_P(value);
24521
0
            }
24522
0
          }
24523
0
          zend_hash_add_new(zobj->properties, name, value);
24524
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24525
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
24526
0
          }
24527
0
          goto exit_assign_obj;
24528
0
        }
24529
0
      } else {
24530
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24531
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24532
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
24533
0
          prop_offset = prop_info->offset;
24534
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24535
0
            prop_info = NULL;
24536
0
          }
24537
0
          goto assign_obj_simple;
24538
0
        }
24539
        /* Fall through to write_property for hooks. */
24540
0
      }
24541
0
    }
24542
44
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24543
44
  } else {
24544
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24545
0
    if (UNEXPECTED(!name)) {
24546
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24547
0
      UNDEF_RESULT();
24548
0
      goto exit_assign_obj;
24549
0
    }
24550
0
  }
24551
24552
44
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24553
44
    ZVAL_DEREF(value);
24554
44
  }
24555
24556
44
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24557
24558
44
  if (IS_CONST != IS_CONST) {
24559
0
    zend_tmp_string_release(tmp_name);
24560
0
  }
24561
24562
52
free_and_exit_assign_obj:
24563
52
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24564
15
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24565
15
  }
24566
52
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24567
52
exit_assign_obj:
24568
52
  if (garbage) {
24569
0
    GC_DTOR_NO_REF(garbage);
24570
0
  }
24571
24572
52
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24573
  /* assign_obj has two opcodes! */
24574
52
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24575
52
}
24576
24577
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24578
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24579
161
{
24580
161
  USE_OPLINE
24581
161
  zval *object, *value, tmp;
24582
161
  zend_object *zobj;
24583
161
  zend_string *name, *tmp_name;
24584
161
  zend_refcounted *garbage = NULL;
24585
24586
161
  SAVE_OPLINE();
24587
161
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24588
161
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
24589
24590
161
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24591
3
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24592
0
      object = Z_REFVAL_P(object);
24593
0
      goto assign_object;
24594
0
    }
24595
3
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24596
3
    value = &EG(uninitialized_zval);
24597
3
    goto free_and_exit_assign_obj;
24598
3
  }
24599
24600
158
assign_object:
24601
158
  zobj = Z_OBJ_P(object);
24602
158
  if (IS_CONST == IS_CONST) {
24603
158
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24604
124
      void **cache_slot = CACHE_ADDR(opline->extended_value);
24605
124
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24606
124
      zval *property_val;
24607
124
      zend_property_info *prop_info;
24608
24609
124
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24610
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24611
24612
0
assign_obj_simple:
24613
0
        property_val = OBJ_PROP(zobj, prop_offset);
24614
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
24615
0
          if (prop_info != NULL) {
24616
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24617
0
            goto free_and_exit_assign_obj;
24618
0
          } else {
24619
0
fast_assign_obj:
24620
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
24621
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24622
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
24623
0
            }
24624
0
            goto exit_assign_obj;
24625
0
          }
24626
0
        }
24627
124
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24628
124
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24629
124
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24630
0
          zobj = zend_lazy_object_init(zobj);
24631
0
          if (!zobj) {
24632
0
            value = &EG(uninitialized_zval);
24633
0
            goto free_and_exit_assign_obj;
24634
0
          }
24635
0
        }
24636
124
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24637
124
          rebuild_object_properties_internal(zobj);
24638
124
        }
24639
124
        if (EXPECTED(zobj->properties != NULL)) {
24640
124
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24641
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24642
0
              GC_DELREF(zobj->properties);
24643
0
            }
24644
0
            zobj->properties = zend_array_dup(zobj->properties);
24645
0
          }
24646
124
          property_val = zend_hash_find_known_hash(zobj->properties, name);
24647
124
          if (property_val) {
24648
0
            goto fast_assign_obj;
24649
0
          }
24650
124
        }
24651
24652
124
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24653
124
          if (IS_CV == IS_CONST) {
24654
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24655
0
              Z_ADDREF_P(value);
24656
0
            }
24657
124
          } else if (IS_CV != IS_TMP_VAR) {
24658
124
            if (Z_ISREF_P(value)) {
24659
0
              if (IS_CV == IS_VAR) {
24660
0
                zend_reference *ref = Z_REF_P(value);
24661
0
                if (GC_DELREF(ref) == 0) {
24662
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24663
0
                  efree_size(ref, sizeof(zend_reference));
24664
0
                  value = &tmp;
24665
0
                } else {
24666
0
                  value = Z_REFVAL_P(value);
24667
0
                  Z_TRY_ADDREF_P(value);
24668
0
                }
24669
0
              } else {
24670
0
                value = Z_REFVAL_P(value);
24671
0
                Z_TRY_ADDREF_P(value);
24672
0
              }
24673
124
            } else if (IS_CV == IS_CV) {
24674
124
              Z_TRY_ADDREF_P(value);
24675
124
            }
24676
124
          }
24677
124
          zend_hash_add_new(zobj->properties, name, value);
24678
124
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24679
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
24680
0
          }
24681
124
          goto exit_assign_obj;
24682
124
        }
24683
124
      } else {
24684
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24685
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24686
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
24687
0
          prop_offset = prop_info->offset;
24688
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24689
0
            prop_info = NULL;
24690
0
          }
24691
0
          goto assign_obj_simple;
24692
0
        }
24693
        /* Fall through to write_property for hooks. */
24694
0
      }
24695
124
    }
24696
34
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24697
34
  } else {
24698
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24699
0
    if (UNEXPECTED(!name)) {
24700
24701
0
      UNDEF_RESULT();
24702
0
      goto exit_assign_obj;
24703
0
    }
24704
0
  }
24705
24706
34
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24707
34
    ZVAL_DEREF(value);
24708
34
  }
24709
24710
34
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24711
24712
34
  if (IS_CONST != IS_CONST) {
24713
0
    zend_tmp_string_release(tmp_name);
24714
0
  }
24715
24716
37
free_and_exit_assign_obj:
24717
37
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24718
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24719
0
  }
24720
24721
161
exit_assign_obj:
24722
161
  if (garbage) {
24723
0
    GC_DTOR_NO_REF(garbage);
24724
0
  }
24725
24726
161
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24727
  /* assign_obj has two opcodes! */
24728
161
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24729
161
}
24730
24731
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24732
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24733
1.62k
{
24734
1.62k
  USE_OPLINE
24735
1.62k
  zval *object_ptr, *orig_object_ptr;
24736
1.62k
  zval *value;
24737
1.62k
  zval *variable_ptr;
24738
1.62k
  zval *dim;
24739
1.62k
  zend_refcounted *garbage = NULL;
24740
24741
1.62k
  SAVE_OPLINE();
24742
1.62k
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24743
24744
1.62k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24745
1.59k
try_assign_dim_array:
24746
1.59k
    SEPARATE_ARRAY(object_ptr);
24747
1.59k
    if (IS_CONST == IS_UNUSED) {
24748
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
24749
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24750
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
24751
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24752
0
          GC_ADDREF(ht);
24753
0
        }
24754
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24755
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24756
0
          zend_array_destroy(ht);
24757
0
          goto assign_dim_error;
24758
0
        }
24759
0
      }
24760
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24761
0
        ZVAL_DEREF(value);
24762
0
      }
24763
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24764
0
      if (UNEXPECTED(value == NULL)) {
24765
0
        zend_cannot_add_element();
24766
0
        goto assign_dim_error;
24767
0
      } else if (IS_CONST == IS_CV) {
24768
0
        if (Z_REFCOUNTED_P(value)) {
24769
0
          Z_ADDREF_P(value);
24770
0
        }
24771
0
      } else if (IS_CONST == IS_VAR) {
24772
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
24773
0
        if (Z_ISREF_P(free_op_data)) {
24774
0
          if (Z_REFCOUNTED_P(value)) {
24775
0
            Z_ADDREF_P(value);
24776
0
          }
24777
0
          zval_ptr_dtor_nogc(free_op_data);
24778
0
        }
24779
0
      } else if (IS_CONST == IS_CONST) {
24780
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24781
0
          Z_ADDREF_P(value);
24782
0
        }
24783
0
      }
24784
1.59k
    } else {
24785
1.59k
      dim = RT_CONSTANT(opline, opline->op2);
24786
1.59k
      if (IS_CONST == IS_CONST) {
24787
1.59k
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24788
1.59k
      } else {
24789
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24790
0
      }
24791
1.59k
      if (UNEXPECTED(variable_ptr == NULL)) {
24792
0
        goto assign_dim_error;
24793
0
      }
24794
1.59k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
24795
1.59k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24796
1.59k
    }
24797
1.59k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24798
127
      ZVAL_COPY(EX_VAR(opline->result.var), value);
24799
127
    }
24800
1.59k
    if (garbage) {
24801
3
      GC_DTOR_NO_REF(garbage);
24802
3
    }
24803
1.59k
  } else {
24804
1.02k
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
24805
91
      object_ptr = Z_REFVAL_P(object_ptr);
24806
91
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24807
51
        goto try_assign_dim_array;
24808
51
      }
24809
91
    }
24810
976
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24811
33
      zend_object *obj = Z_OBJ_P(object_ptr);
24812
24813
33
      GC_ADDREF(obj);
24814
33
      dim = RT_CONSTANT(opline, opline->op2);
24815
33
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24816
0
        dim = ZVAL_UNDEFINED_OP2();
24817
33
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24818
0
        dim++;
24819
0
      }
24820
24821
33
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
24822
33
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24823
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24824
33
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
24825
0
        ZVAL_DEREF(value);
24826
0
      }
24827
24828
33
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24829
24830
33
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24831
0
        zend_objects_store_del(obj);
24832
0
      }
24833
943
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24834
3
      if (IS_CONST == IS_UNUSED) {
24835
0
        zend_use_new_element_for_string();
24836
24837
0
        UNDEF_RESULT();
24838
3
      } else {
24839
3
        dim = RT_CONSTANT(opline, opline->op2);
24840
3
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
24841
3
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24842
24843
3
      }
24844
940
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24845
938
      if (Z_ISREF_P(orig_object_ptr)
24846
938
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24847
938
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24848
0
        dim = RT_CONSTANT(opline, opline->op2);
24849
24850
0
        UNDEF_RESULT();
24851
938
      } else {
24852
938
        HashTable *ht = zend_new_array(8);
24853
938
        uint8_t old_type = Z_TYPE_P(object_ptr);
24854
24855
938
        ZVAL_ARR(object_ptr, ht);
24856
938
        if (UNEXPECTED(old_type == IS_FALSE)) {
24857
0
          GC_ADDREF(ht);
24858
0
          zend_false_to_array_deprecated();
24859
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24860
0
            zend_array_destroy(ht);
24861
0
            goto assign_dim_error;
24862
0
          }
24863
0
        }
24864
938
        goto try_assign_dim_array;
24865
938
      }
24866
938
    } else {
24867
2
      zend_use_scalar_as_array();
24868
2
      dim = RT_CONSTANT(opline, opline->op2);
24869
2
assign_dim_error:
24870
24871
2
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24872
0
        ZVAL_NULL(EX_VAR(opline->result.var));
24873
0
      }
24874
2
    }
24875
976
  }
24876
1.62k
  if (IS_CONST != IS_UNUSED) {
24877
24878
1.62k
  }
24879
1.62k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24880
  /* assign_dim has two opcodes! */
24881
1.62k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24882
1.62k
}
24883
24884
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24885
94
{
24886
94
  USE_OPLINE
24887
94
  zval *object_ptr, *orig_object_ptr;
24888
94
  zval *value;
24889
94
  zval *variable_ptr;
24890
94
  zval *dim;
24891
94
  zend_refcounted *garbage = NULL;
24892
24893
94
  SAVE_OPLINE();
24894
94
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24895
24896
94
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24897
94
try_assign_dim_array:
24898
94
    SEPARATE_ARRAY(object_ptr);
24899
94
    if (IS_CONST == IS_UNUSED) {
24900
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24901
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24902
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
24903
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24904
0
          GC_ADDREF(ht);
24905
0
        }
24906
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24907
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24908
0
          zend_array_destroy(ht);
24909
0
          goto assign_dim_error;
24910
0
        }
24911
0
      }
24912
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24913
0
        ZVAL_DEREF(value);
24914
0
      }
24915
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24916
0
      if (UNEXPECTED(value == NULL)) {
24917
0
        zend_cannot_add_element();
24918
0
        goto assign_dim_error;
24919
0
      } else if (IS_TMP_VAR == IS_CV) {
24920
0
        if (Z_REFCOUNTED_P(value)) {
24921
0
          Z_ADDREF_P(value);
24922
0
        }
24923
0
      } else if (IS_TMP_VAR == IS_VAR) {
24924
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
24925
0
        if (Z_ISREF_P(free_op_data)) {
24926
0
          if (Z_REFCOUNTED_P(value)) {
24927
0
            Z_ADDREF_P(value);
24928
0
          }
24929
0
          zval_ptr_dtor_nogc(free_op_data);
24930
0
        }
24931
0
      } else if (IS_TMP_VAR == IS_CONST) {
24932
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24933
0
          Z_ADDREF_P(value);
24934
0
        }
24935
0
      }
24936
94
    } else {
24937
94
      dim = RT_CONSTANT(opline, opline->op2);
24938
94
      if (IS_CONST == IS_CONST) {
24939
94
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24940
94
      } else {
24941
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24942
0
      }
24943
94
      if (UNEXPECTED(variable_ptr == NULL)) {
24944
0
        goto assign_dim_error;
24945
0
      }
24946
94
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24947
94
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24948
94
    }
24949
94
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24950
11
      ZVAL_COPY(EX_VAR(opline->result.var), value);
24951
11
    }
24952
94
    if (garbage) {
24953
36
      GC_DTOR_NO_REF(garbage);
24954
36
    }
24955
94
  } else {
24956
32
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
24957
11
      object_ptr = Z_REFVAL_P(object_ptr);
24958
11
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24959
3
        goto try_assign_dim_array;
24960
3
      }
24961
11
    }
24962
29
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24963
0
      zend_object *obj = Z_OBJ_P(object_ptr);
24964
24965
0
      GC_ADDREF(obj);
24966
0
      dim = RT_CONSTANT(opline, opline->op2);
24967
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24968
0
        dim = ZVAL_UNDEFINED_OP2();
24969
0
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24970
0
        dim++;
24971
0
      }
24972
24973
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24974
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24975
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24976
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
24977
0
        ZVAL_DEREF(value);
24978
0
      }
24979
24980
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24981
24982
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24983
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24984
0
        zend_objects_store_del(obj);
24985
0
      }
24986
29
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24987
0
      if (IS_CONST == IS_UNUSED) {
24988
0
        zend_use_new_element_for_string();
24989
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24990
0
        UNDEF_RESULT();
24991
0
      } else {
24992
0
        dim = RT_CONSTANT(opline, opline->op2);
24993
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24994
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24995
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24996
0
      }
24997
29
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24998
29
      if (Z_ISREF_P(orig_object_ptr)
24999
29
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25000
29
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25001
0
        dim = RT_CONSTANT(opline, opline->op2);
25002
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25003
0
        UNDEF_RESULT();
25004
29
      } else {
25005
29
        HashTable *ht = zend_new_array(8);
25006
29
        uint8_t old_type = Z_TYPE_P(object_ptr);
25007
25008
29
        ZVAL_ARR(object_ptr, ht);
25009
29
        if (UNEXPECTED(old_type == IS_FALSE)) {
25010
0
          GC_ADDREF(ht);
25011
0
          zend_false_to_array_deprecated();
25012
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25013
0
            zend_array_destroy(ht);
25014
0
            goto assign_dim_error;
25015
0
          }
25016
0
        }
25017
29
        goto try_assign_dim_array;
25018
29
      }
25019
29
    } else {
25020
0
      zend_use_scalar_as_array();
25021
0
      dim = RT_CONSTANT(opline, opline->op2);
25022
0
assign_dim_error:
25023
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25024
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25025
0
        ZVAL_NULL(EX_VAR(opline->result.var));
25026
0
      }
25027
0
    }
25028
29
  }
25029
94
  if (IS_CONST != IS_UNUSED) {
25030
25031
94
  }
25032
94
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25033
  /* assign_dim has two opcodes! */
25034
94
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25035
94
}
25036
25037
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25038
210
{
25039
210
  USE_OPLINE
25040
210
  zval *object_ptr, *orig_object_ptr;
25041
210
  zval *value;
25042
210
  zval *variable_ptr;
25043
210
  zval *dim;
25044
210
  zend_refcounted *garbage = NULL;
25045
25046
210
  SAVE_OPLINE();
25047
210
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25048
25049
210
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25050
200
try_assign_dim_array:
25051
200
    SEPARATE_ARRAY(object_ptr);
25052
200
    if (IS_CONST == IS_UNUSED) {
25053
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25054
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
25055
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
25056
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
25057
0
          GC_ADDREF(ht);
25058
0
        }
25059
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25060
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
25061
0
          zend_array_destroy(ht);
25062
0
          goto assign_dim_error;
25063
0
        }
25064
0
      }
25065
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
25066
0
        ZVAL_DEREF(value);
25067
0
      }
25068
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
25069
0
      if (UNEXPECTED(value == NULL)) {
25070
0
        zend_cannot_add_element();
25071
0
        goto assign_dim_error;
25072
0
      } else if (IS_VAR == IS_CV) {
25073
0
        if (Z_REFCOUNTED_P(value)) {
25074
0
          Z_ADDREF_P(value);
25075
0
        }
25076
0
      } else if (IS_VAR == IS_VAR) {
25077
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
25078
0
        if (Z_ISREF_P(free_op_data)) {
25079
0
          if (Z_REFCOUNTED_P(value)) {
25080
0
            Z_ADDREF_P(value);
25081
0
          }
25082
0
          zval_ptr_dtor_nogc(free_op_data);
25083
0
        }
25084
0
      } else if (IS_VAR == IS_CONST) {
25085
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
25086
0
          Z_ADDREF_P(value);
25087
0
        }
25088
0
      }
25089
200
    } else {
25090
200
      dim = RT_CONSTANT(opline, opline->op2);
25091
200
      if (IS_CONST == IS_CONST) {
25092
200
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25093
200
      } else {
25094
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25095
0
      }
25096
200
      if (UNEXPECTED(variable_ptr == NULL)) {
25097
0
        goto assign_dim_error;
25098
0
      }
25099
200
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25100
200
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
25101
200
    }
25102
200
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25103
144
      ZVAL_COPY(EX_VAR(opline->result.var), value);
25104
144
    }
25105
200
    if (garbage) {
25106
85
      GC_DTOR_NO_REF(garbage);
25107
85
    }
25108
200
  } else {
25109
92
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
25110
5
      object_ptr = Z_REFVAL_P(object_ptr);
25111
5
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25112
0
        goto try_assign_dim_array;
25113
0
      }
25114
5
    }
25115
92
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
25116
10
      zend_object *obj = Z_OBJ_P(object_ptr);
25117
25118
10
      GC_ADDREF(obj);
25119
10
      dim = RT_CONSTANT(opline, opline->op2);
25120
10
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
25121
0
        dim = ZVAL_UNDEFINED_OP2();
25122
10
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
25123
0
        dim++;
25124
0
      }
25125
25126
10
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25127
10
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
25128
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25129
10
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
25130
10
        ZVAL_DEREF(value);
25131
10
      }
25132
25133
10
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
25134
25135
10
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25136
10
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
25137
0
        zend_objects_store_del(obj);
25138
0
      }
25139
82
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
25140
0
      if (IS_CONST == IS_UNUSED) {
25141
0
        zend_use_new_element_for_string();
25142
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25143
0
        UNDEF_RESULT();
25144
0
      } else {
25145
0
        dim = RT_CONSTANT(opline, opline->op2);
25146
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25147
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25148
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25149
0
      }
25150
82
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25151
82
      if (Z_ISREF_P(orig_object_ptr)
25152
82
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25153
82
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25154
0
        dim = RT_CONSTANT(opline, opline->op2);
25155
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25156
0
        UNDEF_RESULT();
25157
82
      } else {
25158
82
        HashTable *ht = zend_new_array(8);
25159
82
        uint8_t old_type = Z_TYPE_P(object_ptr);
25160
25161
82
        ZVAL_ARR(object_ptr, ht);
25162
82
        if (UNEXPECTED(old_type == IS_FALSE)) {
25163
0
          GC_ADDREF(ht);
25164
0
          zend_false_to_array_deprecated();
25165
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25166
0
            zend_array_destroy(ht);
25167
0
            goto assign_dim_error;
25168
0
          }
25169
0
        }
25170
82
        goto try_assign_dim_array;
25171
82
      }
25172
82
    } else {
25173
0
      zend_use_scalar_as_array();
25174
0
      dim = RT_CONSTANT(opline, opline->op2);
25175
0
assign_dim_error:
25176
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25177
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25178
0
        ZVAL_NULL(EX_VAR(opline->result.var));
25179
0
      }
25180
0
    }
25181
92
  }
25182
210
  if (IS_CONST != IS_UNUSED) {
25183
25184
210
  }
25185
210
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25186
  /* assign_dim has two opcodes! */
25187
210
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25188
210
}
25189
25190
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25191
416
{
25192
416
  USE_OPLINE
25193
416
  zval *object_ptr, *orig_object_ptr;
25194
416
  zval *value;
25195
416
  zval *variable_ptr;
25196
416
  zval *dim;
25197
416
  zend_refcounted *garbage = NULL;
25198
25199
416
  SAVE_OPLINE();
25200
416
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25201
25202
416
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25203
416
try_assign_dim_array:
25204
416
    SEPARATE_ARRAY(object_ptr);
25205
416
    if (IS_CONST == IS_UNUSED) {
25206
0
      value = EX_VAR((opline+1)->op1.var);
25207
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
25208
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
25209
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
25210
0
          GC_ADDREF(ht);
25211
0
        }
25212
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25213
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
25214
0
          zend_array_destroy(ht);
25215
0
          goto assign_dim_error;
25216
0
        }
25217
0
      }
25218
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
25219
0
        ZVAL_DEREF(value);
25220
0
      }
25221
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
25222
0
      if (UNEXPECTED(value == NULL)) {
25223
0
        zend_cannot_add_element();
25224
0
        goto assign_dim_error;
25225
0
      } else if (IS_CV == IS_CV) {
25226
0
        if (Z_REFCOUNTED_P(value)) {
25227
0
          Z_ADDREF_P(value);
25228
0
        }
25229
0
      } else if (IS_CV == IS_VAR) {
25230
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
25231
0
        if (Z_ISREF_P(free_op_data)) {
25232
0
          if (Z_REFCOUNTED_P(value)) {
25233
0
            Z_ADDREF_P(value);
25234
0
          }
25235
0
          zval_ptr_dtor_nogc(free_op_data);
25236
0
        }
25237
0
      } else if (IS_CV == IS_CONST) {
25238
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
25239
0
          Z_ADDREF_P(value);
25240
0
        }
25241
0
      }
25242
416
    } else {
25243
416
      dim = RT_CONSTANT(opline, opline->op2);
25244
416
      if (IS_CONST == IS_CONST) {
25245
416
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25246
416
      } else {
25247
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25248
0
      }
25249
416
      if (UNEXPECTED(variable_ptr == NULL)) {
25250
0
        goto assign_dim_error;
25251
0
      }
25252
416
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
25253
416
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
25254
416
    }
25255
416
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25256
246
      ZVAL_COPY(EX_VAR(opline->result.var), value);
25257
246
    }
25258
416
    if (garbage) {
25259
0
      GC_DTOR_NO_REF(garbage);
25260
0
    }
25261
416
  } else {
25262
194
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
25263
0
      object_ptr = Z_REFVAL_P(object_ptr);
25264
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25265
0
        goto try_assign_dim_array;
25266
0
      }
25267
0
    }
25268
194
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
25269
0
      zend_object *obj = Z_OBJ_P(object_ptr);
25270
25271
0
      GC_ADDREF(obj);
25272
0
      dim = RT_CONSTANT(opline, opline->op2);
25273
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
25274
0
        dim = ZVAL_UNDEFINED_OP2();
25275
0
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
25276
0
        dim++;
25277
0
      }
25278
25279
0
      value = EX_VAR((opline+1)->op1.var);
25280
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
25281
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25282
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
25283
0
        ZVAL_DEREF(value);
25284
0
      }
25285
25286
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
25287
25288
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
25289
0
        zend_objects_store_del(obj);
25290
0
      }
25291
194
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
25292
0
      if (IS_CONST == IS_UNUSED) {
25293
0
        zend_use_new_element_for_string();
25294
25295
0
        UNDEF_RESULT();
25296
0
      } else {
25297
0
        dim = RT_CONSTANT(opline, opline->op2);
25298
0
        value = EX_VAR((opline+1)->op1.var);
25299
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25300
25301
0
      }
25302
194
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25303
194
      if (Z_ISREF_P(orig_object_ptr)
25304
194
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25305
194
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25306
0
        dim = RT_CONSTANT(opline, opline->op2);
25307
25308
0
        UNDEF_RESULT();
25309
194
      } else {
25310
194
        HashTable *ht = zend_new_array(8);
25311
194
        uint8_t old_type = Z_TYPE_P(object_ptr);
25312
25313
194
        ZVAL_ARR(object_ptr, ht);
25314
194
        if (UNEXPECTED(old_type == IS_FALSE)) {
25315
0
          GC_ADDREF(ht);
25316
0
          zend_false_to_array_deprecated();
25317
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25318
0
            zend_array_destroy(ht);
25319
0
            goto assign_dim_error;
25320
0
          }
25321
0
        }
25322
194
        goto try_assign_dim_array;
25323
194
      }
25324
194
    } else {
25325
0
      zend_use_scalar_as_array();
25326
0
      dim = RT_CONSTANT(opline, opline->op2);
25327
0
assign_dim_error:
25328
25329
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25330
0
        ZVAL_NULL(EX_VAR(opline->result.var));
25331
0
      }
25332
0
    }
25333
194
  }
25334
416
  if (IS_CONST != IS_UNUSED) {
25335
25336
416
  }
25337
416
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25338
  /* assign_dim has two opcodes! */
25339
416
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25340
416
}
25341
25342
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25343
1.82k
{
25344
1.82k
  USE_OPLINE
25345
1.82k
  zval *value;
25346
1.82k
  zval *variable_ptr;
25347
25348
1.82k
  SAVE_OPLINE();
25349
1.82k
  value = RT_CONSTANT(opline, opline->op2);
25350
1.82k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25351
25352
1.82k
  if (0 || UNEXPECTED(0)) {
25353
0
    zend_refcounted *garbage = NULL;
25354
25355
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
25356
0
    if (UNEXPECTED(0)) {
25357
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
25358
0
    }
25359
0
    if (garbage) {
25360
0
      GC_DTOR_NO_REF(garbage);
25361
0
    }
25362
1.82k
  } else {
25363
1.82k
    value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
25364
1.82k
  }
25365
1.82k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25366
  /* zend_assign_to_variable() always takes care of op2, never free it! */
25367
25368
1.82k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25369
1.82k
}
25370
25371
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25372
564
{
25373
564
  USE_OPLINE
25374
564
  zval *value;
25375
564
  zval *variable_ptr;
25376
25377
564
  SAVE_OPLINE();
25378
564
  value = RT_CONSTANT(opline, opline->op2);
25379
564
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25380
25381
564
  if (0 || UNEXPECTED(1)) {
25382
564
    zend_refcounted *garbage = NULL;
25383
25384
564
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
25385
564
    if (UNEXPECTED(1)) {
25386
564
      ZVAL_COPY(EX_VAR(opline->result.var), value);
25387
564
    }
25388
564
    if (garbage) {
25389
0
      GC_DTOR_NO_REF(garbage);
25390
0
    }
25391
564
  } else {
25392
0
    value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
25393
0
  }
25394
564
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25395
  /* zend_assign_to_variable() always takes care of op2, never free it! */
25396
25397
564
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25398
564
}
25399
25400
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25401
34
{
25402
34
  USE_OPLINE
25403
34
  zval *property, *container, *value_ptr;
25404
25405
34
  SAVE_OPLINE();
25406
25407
34
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25408
34
  property = RT_CONSTANT(opline, opline->op2);
25409
25410
34
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25411
25412
34
  if (1) {
25413
34
    if (IS_VAR == IS_UNUSED) {
25414
0
      if (IS_CONST == IS_CONST) {
25415
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25416
0
      } else {
25417
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25418
0
      }
25419
34
    } else {
25420
34
      if (IS_CONST == IS_CONST) {
25421
34
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25422
34
      } else {
25423
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25424
0
      }
25425
34
    }
25426
34
  } else {
25427
0
    zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25428
0
  }
25429
25430
34
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25431
25432
34
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25433
34
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25434
34
}
25435
25436
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
25437
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25438
23
{
25439
23
  USE_OPLINE
25440
23
  zval *property, *container, *value_ptr;
25441
25442
23
  SAVE_OPLINE();
25443
25444
23
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25445
23
  property = RT_CONSTANT(opline, opline->op2);
25446
25447
23
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
25448
25449
23
  if (1) {
25450
23
    if (IS_VAR == IS_UNUSED) {
25451
0
      if (IS_CONST == IS_CONST) {
25452
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25453
0
      } else {
25454
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25455
0
      }
25456
23
    } else {
25457
23
      if (IS_CONST == IS_CONST) {
25458
23
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25459
23
      } else {
25460
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25461
0
      }
25462
23
    }
25463
23
  } else {
25464
0
    zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25465
0
  }
25466
25467
23
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25468
25469
25470
23
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25471
23
}
25472
25473
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
25474
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25475
128
{
25476
128
  USE_OPLINE
25477
128
  zval *function_name;
25478
128
  zend_class_entry *ce;
25479
128
  uint32_t call_info;
25480
128
  zend_function *fbc;
25481
128
  zend_execute_data *call;
25482
25483
128
  SAVE_OPLINE();
25484
25485
128
  if (IS_VAR == IS_CONST) {
25486
    /* no function found. try a static method in class */
25487
0
    ce = CACHED_PTR(opline->result.num);
25488
0
    if (UNEXPECTED(ce == NULL)) {
25489
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
25490
0
      if (UNEXPECTED(ce == NULL)) {
25491
25492
0
        HANDLE_EXCEPTION();
25493
0
      }
25494
0
      if (IS_CONST != IS_CONST) {
25495
0
        CACHE_PTR(opline->result.num, ce);
25496
0
      }
25497
0
    }
25498
128
  } else if (IS_VAR == IS_UNUSED) {
25499
0
    ce = zend_fetch_class(NULL, opline->op1.num);
25500
0
    if (UNEXPECTED(ce == NULL)) {
25501
25502
0
      HANDLE_EXCEPTION();
25503
0
    }
25504
128
  } else {
25505
128
    ce = Z_CE_P(EX_VAR(opline->op1.var));
25506
128
  }
25507
25508
128
  if (IS_VAR == IS_CONST &&
25509
128
      IS_CONST == IS_CONST &&
25510
128
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
25511
    /* nothing to do */
25512
128
  } else if (IS_VAR != IS_CONST &&
25513
128
             IS_CONST == IS_CONST &&
25514
128
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
25515
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
25516
128
  } else if (IS_CONST != IS_UNUSED) {
25517
128
    function_name = RT_CONSTANT(opline, opline->op2);
25518
128
    if (IS_CONST != IS_CONST) {
25519
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
25520
0
        do {
25521
0
          if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
25522
0
            function_name = Z_REFVAL_P(function_name);
25523
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
25524
0
              break;
25525
0
            }
25526
0
          } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
25527
0
            ZVAL_UNDEFINED_OP2();
25528
0
            if (UNEXPECTED(EG(exception) != NULL)) {
25529
0
              HANDLE_EXCEPTION();
25530
0
            }
25531
0
          }
25532
0
          zend_throw_error(NULL, "Method name must be a string");
25533
25534
0
          HANDLE_EXCEPTION();
25535
0
        } while (0);
25536
0
      }
25537
0
    }
25538
25539
128
    if (ce->get_static_method) {
25540
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
25541
128
    } else {
25542
128
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
25543
128
    }
25544
128
    if (UNEXPECTED(fbc == NULL)) {
25545
5
      if (EXPECTED(!EG(exception))) {
25546
5
        zend_undefined_method(ce, Z_STR_P(function_name));
25547
5
      }
25548
25549
5
      HANDLE_EXCEPTION();
25550
5
    }
25551
123
    if (IS_CONST == IS_CONST &&
25552
123
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
25553
123
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
25554
83
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
25555
83
    }
25556
123
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
25557
27
      init_func_run_time_cache(&fbc->op_array);
25558
27
    }
25559
123
    if (IS_CONST != IS_CONST) {
25560
25561
0
    }
25562
123
  } else {
25563
0
    if (UNEXPECTED(ce->constructor == NULL)) {
25564
0
      zend_throw_error(NULL, "Cannot call constructor");
25565
0
      HANDLE_EXCEPTION();
25566
0
    }
25567
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
25568
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
25569
0
      HANDLE_EXCEPTION();
25570
0
    }
25571
0
    fbc = ce->constructor;
25572
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
25573
0
      init_func_run_time_cache(&fbc->op_array);
25574
0
    }
25575
0
  }
25576
25577
123
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
25578
10
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
25579
5
      ce = (zend_class_entry*)Z_OBJ(EX(This));
25580
5
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
25581
5
    } else {
25582
5
      zend_non_static_method_call(fbc);
25583
5
      HANDLE_EXCEPTION();
25584
5
    }
25585
113
  } else {
25586
    /* previous opcode is ZEND_FETCH_CLASS */
25587
113
    if (IS_VAR == IS_UNUSED
25588
113
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
25589
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
25590
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
25591
0
        ce = Z_OBJCE(EX(This));
25592
0
      } else {
25593
0
        ce = Z_CE(EX(This));
25594
0
      }
25595
0
    }
25596
113
    call_info = ZEND_CALL_NESTED_FUNCTION;
25597
113
  }
25598
25599
118
  call = zend_vm_stack_push_call_frame(call_info,
25600
118
    fbc, opline->extended_value, ce);
25601
118
  call->prev_execute_data = EX(call);
25602
118
  EX(call) = call;
25603
25604
118
  ZEND_VM_NEXT_OPCODE();
25605
118
}
25606
25607
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25608
0
{
25609
0
  USE_OPLINE
25610
0
  zval *varptr, *arg;
25611
25612
0
  if (IS_CONST == IS_CONST) {
25613
0
    SAVE_OPLINE();
25614
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25615
0
    uint32_t arg_num;
25616
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25617
0
    if (UNEXPECTED(!arg)) {
25618
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25619
0
      HANDLE_EXCEPTION();
25620
0
    }
25621
0
  } else {
25622
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25623
0
  }
25624
25625
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25626
0
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25627
0
    SAVE_OPLINE();
25628
0
    ZVAL_UNDEFINED_OP1();
25629
0
    ZVAL_NULL(arg);
25630
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25631
0
  }
25632
25633
0
  if (IS_VAR == IS_CV) {
25634
0
    ZVAL_COPY_DEREF(arg, varptr);
25635
0
  } else /* if (IS_VAR == IS_VAR) */ {
25636
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
25637
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
25638
25639
0
      varptr = Z_REFVAL_P(varptr);
25640
0
      ZVAL_COPY_VALUE(arg, varptr);
25641
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25642
0
        efree_size(ref, sizeof(zend_reference));
25643
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
25644
0
        Z_ADDREF_P(arg);
25645
0
      }
25646
0
    } else {
25647
0
      ZVAL_COPY_VALUE(arg, varptr);
25648
0
    }
25649
0
  }
25650
25651
0
  ZEND_VM_NEXT_OPCODE();
25652
0
}
25653
25654
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25655
64
{
25656
64
  USE_OPLINE
25657
64
  zval *varptr, *arg;
25658
25659
64
  if (IS_CONST == IS_CONST) {
25660
64
    SAVE_OPLINE();
25661
64
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25662
64
    uint32_t arg_num;
25663
64
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25664
64
    if (UNEXPECTED(!arg)) {
25665
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25666
0
      HANDLE_EXCEPTION();
25667
0
    }
25668
64
  } else {
25669
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25670
0
  }
25671
25672
64
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25673
64
  ZVAL_COPY_VALUE(arg, varptr);
25674
25675
64
  if (EXPECTED(Z_ISREF_P(varptr))) {
25676
64
    ZEND_VM_NEXT_OPCODE();
25677
64
  }
25678
25679
64
  SAVE_OPLINE();
25680
0
  ZVAL_NEW_REF(arg, arg);
25681
0
  zend_error(E_NOTICE, "Only variables should be passed by reference");
25682
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25683
0
}
25684
25685
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25686
70
{
25687
70
  USE_OPLINE
25688
70
  zval *varptr, *arg;
25689
70
  uint32_t arg_num;
25690
25691
70
  if (IS_CONST == IS_CONST) {
25692
70
    SAVE_OPLINE();
25693
70
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25694
70
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25695
70
    if (UNEXPECTED(!arg)) {
25696
11
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25697
11
      HANDLE_EXCEPTION();
25698
11
    }
25699
70
  } else {
25700
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25701
0
    arg_num = opline->op2.num;
25702
0
  }
25703
25704
59
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25705
59
    if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25706
3
      goto send_var;
25707
3
    }
25708
25709
56
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25710
56
    ZVAL_COPY_VALUE(arg, varptr);
25711
25712
56
    if (EXPECTED(Z_ISREF_P(varptr) ||
25713
56
        QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25714
56
      ZEND_VM_NEXT_OPCODE();
25715
56
    }
25716
56
  } else {
25717
0
    if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25718
0
      goto send_var;
25719
0
    }
25720
25721
0
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25722
0
    ZVAL_COPY_VALUE(arg, varptr);
25723
25724
0
    if (EXPECTED(Z_ISREF_P(varptr) ||
25725
0
        ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25726
0
      ZEND_VM_NEXT_OPCODE();
25727
0
    }
25728
0
  }
25729
25730
59
  SAVE_OPLINE();
25731
0
  ZVAL_NEW_REF(arg, arg);
25732
0
  zend_error(E_NOTICE, "Only variables should be passed by reference");
25733
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25734
25735
3
send_var:
25736
3
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25737
3
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
25738
3
    zend_refcounted *ref = Z_COUNTED_P(varptr);
25739
25740
3
    varptr = Z_REFVAL_P(varptr);
25741
3
    ZVAL_COPY_VALUE(arg, varptr);
25742
3
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25743
3
      efree_size(ref, sizeof(zend_reference));
25744
3
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
25745
0
      Z_ADDREF_P(arg);
25746
0
    }
25747
3
  } else {
25748
0
    ZVAL_COPY_VALUE(arg, varptr);
25749
0
  }
25750
3
  ZEND_VM_NEXT_OPCODE();
25751
3
}
25752
25753
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25754
26
{
25755
26
  USE_OPLINE
25756
26
  zval *varptr, *arg;
25757
25758
26
  SAVE_OPLINE();
25759
26
  if (IS_CONST == IS_CONST) {
25760
26
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25761
26
    uint32_t arg_num;
25762
26
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25763
26
    if (UNEXPECTED(!arg)) {
25764
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25765
0
      HANDLE_EXCEPTION();
25766
0
    }
25767
26
  } else {
25768
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25769
0
  }
25770
25771
26
  varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25772
26
  if (Z_ISREF_P(varptr)) {
25773
0
    Z_ADDREF_P(varptr);
25774
26
  } else {
25775
26
    ZVAL_MAKE_REF_EX(varptr, 2);
25776
26
  }
25777
26
  ZVAL_REF(arg, Z_REF_P(varptr));
25778
25779
26
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25780
26
  ZEND_VM_NEXT_OPCODE();
25781
26
}
25782
25783
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25784
0
{
25785
0
  USE_OPLINE
25786
0
  zval *varptr, *arg;
25787
0
  uint32_t arg_num;
25788
25789
0
  if (IS_CONST == IS_CONST) {
25790
0
    SAVE_OPLINE();
25791
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25792
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25793
0
    if (UNEXPECTED(!arg)) {
25794
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25795
0
      HANDLE_EXCEPTION();
25796
0
    }
25797
0
  } else {
25798
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25799
0
    arg_num = opline->op2.num;
25800
0
  }
25801
25802
0
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25803
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25804
0
      goto send_var_by_ref;
25805
0
    }
25806
0
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25807
0
send_var_by_ref:
25808
0
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25809
0
    if (Z_ISREF_P(varptr)) {
25810
0
      Z_ADDREF_P(varptr);
25811
0
    } else {
25812
0
      ZVAL_MAKE_REF_EX(varptr, 2);
25813
0
    }
25814
0
    ZVAL_REF(arg, Z_REF_P(varptr));
25815
25816
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25817
0
    ZEND_VM_NEXT_OPCODE();
25818
0
  }
25819
25820
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25821
0
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25822
0
    SAVE_OPLINE();
25823
0
    ZVAL_UNDEFINED_OP1();
25824
0
    ZVAL_NULL(arg);
25825
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25826
0
  }
25827
25828
0
  if (IS_VAR == IS_CV) {
25829
0
    ZVAL_COPY_DEREF(arg, varptr);
25830
0
  } else /* if (IS_VAR == IS_VAR) */ {
25831
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
25832
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
25833
25834
0
      varptr = Z_REFVAL_P(varptr);
25835
0
      ZVAL_COPY_VALUE(arg, varptr);
25836
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25837
0
        efree_size(ref, sizeof(zend_reference));
25838
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
25839
0
        Z_ADDREF_P(arg);
25840
0
      }
25841
0
    } else {
25842
0
      ZVAL_COPY_VALUE(arg, varptr);
25843
0
    }
25844
0
  }
25845
25846
0
  ZEND_VM_NEXT_OPCODE();
25847
0
}
25848
25849
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25850
66
{
25851
66
  USE_OPLINE
25852
66
  zval *varptr, *arg;
25853
25854
66
  if (IS_CONST == IS_CONST) {
25855
    // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
25856
66
    SAVE_OPLINE();
25857
66
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25858
66
    uint32_t arg_num;
25859
66
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25860
66
    if (UNEXPECTED(!arg)) {
25861
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25862
0
      HANDLE_EXCEPTION();
25863
0
    }
25864
66
  } else {
25865
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25866
0
  }
25867
25868
66
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
25869
32
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25870
32
    if (Z_ISREF_P(varptr)) {
25871
0
      Z_ADDREF_P(varptr);
25872
32
    } else {
25873
32
      ZVAL_MAKE_REF_EX(varptr, 2);
25874
32
    }
25875
32
    ZVAL_REF(arg, Z_REF_P(varptr));
25876
25877
32
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25878
32
    ZEND_VM_NEXT_OPCODE();
25879
32
  }
25880
25881
34
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25882
25883
34
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
25884
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
25885
25886
0
    varptr = Z_REFVAL_P(varptr);
25887
0
    ZVAL_COPY_VALUE(arg, varptr);
25888
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25889
0
      efree_size(ref, sizeof(zend_reference));
25890
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
25891
0
      Z_ADDREF_P(arg);
25892
0
    }
25893
34
  } else {
25894
34
    ZVAL_COPY_VALUE(arg, varptr);
25895
34
  }
25896
25897
34
  ZEND_VM_NEXT_OPCODE();
25898
34
}
25899
25900
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25901
187
{
25902
187
  zend_class_entry *ce, *scope;
25903
187
  zend_class_constant *c;
25904
187
  zval *value, *zv, *constant_zv;
25905
187
  zend_string *constant_name;
25906
187
  USE_OPLINE
25907
25908
187
  SAVE_OPLINE();
25909
25910
187
  do {
25911
187
    if (IS_VAR == IS_CONST && IS_CONST == IS_CONST) {
25912
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
25913
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
25914
0
        break;
25915
0
      }
25916
0
    }
25917
187
    if (IS_VAR == IS_CONST) {
25918
0
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
25919
0
        ce = CACHED_PTR(opline->extended_value);
25920
0
      } else {
25921
0
        ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
25922
0
        if (UNEXPECTED(ce == NULL)) {
25923
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
25924
25925
0
          HANDLE_EXCEPTION();
25926
0
        }
25927
0
        CACHE_PTR(opline->extended_value, ce);
25928
0
      }
25929
187
    } else if (IS_VAR == IS_UNUSED) {
25930
0
      ce = zend_fetch_class(NULL, opline->op1.num);
25931
0
      if (UNEXPECTED(ce == NULL)) {
25932
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
25933
25934
0
        HANDLE_EXCEPTION();
25935
0
      }
25936
187
    } else {
25937
187
      ce = Z_CE_P(EX_VAR(opline->op1.var));
25938
187
    }
25939
187
    if (IS_VAR != IS_CONST
25940
187
      && IS_CONST == IS_CONST
25941
187
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
25942
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
25943
0
      break;
25944
0
    }
25945
25946
187
    constant_zv = RT_CONSTANT(opline, opline->op2);
25947
187
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
25948
42
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
25949
42
      ZVAL_UNDEF(EX_VAR(opline->result.var));
25950
25951
42
      HANDLE_EXCEPTION();
25952
42
    }
25953
145
    constant_name = Z_STR_P(constant_zv);
25954
    /* Magic 'class' for constant OP2 is caught at compile-time */
25955
145
    if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
25956
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
25957
25958
0
      ZEND_VM_NEXT_OPCODE();
25959
0
    }
25960
145
    zv = IS_CONST == IS_CONST
25961
145
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
25962
145
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
25963
25964
145
    if (EXPECTED(zv != NULL)) {
25965
137
      c = Z_PTR_P(zv);
25966
137
      scope = EX(func)->op_array.scope;
25967
137
      if (!zend_verify_const_access(c, scope)) {
25968
0
        zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25969
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
25970
25971
0
        HANDLE_EXCEPTION();
25972
0
      }
25973
25974
137
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
25975
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25976
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
25977
25978
0
        HANDLE_EXCEPTION();
25979
0
      }
25980
25981
137
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
25982
137
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
25983
0
        if (c->ce->type == ZEND_USER_CLASS) {
25984
          /* Recursion protection only applied to user constants, GH-18463 */
25985
0
          CONST_PROTECT_RECURSION(c);
25986
0
        }
25987
0
        zend_deprecated_class_constant(c, constant_name);
25988
0
        if (c->ce->type == ZEND_USER_CLASS) {
25989
0
          CONST_UNPROTECT_RECURSION(c);
25990
0
        }
25991
25992
0
        if (EG(exception)) {
25993
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
25994
25995
0
          HANDLE_EXCEPTION();
25996
0
        }
25997
0
      }
25998
25999
137
      value = &c->value;
26000
      // Enums require loading of all class constants to build the backed enum table
26001
137
      if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
26002
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
26003
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26004
26005
0
          HANDLE_EXCEPTION();
26006
0
        }
26007
0
      }
26008
137
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
26009
0
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
26010
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26011
26012
0
          HANDLE_EXCEPTION();
26013
0
        }
26014
0
      }
26015
137
      if (IS_CONST == IS_CONST && !is_constant_deprecated) {
26016
137
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
26017
137
      }
26018
137
    } else {
26019
8
      zend_throw_error(NULL, "Undefined constant %s::%s",
26020
8
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26021
8
      ZVAL_UNDEF(EX_VAR(opline->result.var));
26022
26023
8
      HANDLE_EXCEPTION();
26024
8
    }
26025
145
  } while (0);
26026
26027
137
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
26028
26029
137
  ZEND_VM_NEXT_OPCODE();
26030
137
}
26031
26032
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26033
248
{
26034
248
  USE_OPLINE
26035
248
  zval *expr_ptr, new_expr;
26036
26037
248
  SAVE_OPLINE();
26038
248
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
26039
248
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
26040
0
    expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26041
0
    if (Z_ISREF_P(expr_ptr)) {
26042
0
      Z_ADDREF_P(expr_ptr);
26043
0
    } else {
26044
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
26045
0
    }
26046
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26047
248
  } else {
26048
248
    expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26049
248
    if (IS_VAR == IS_TMP_VAR) {
26050
      /* pass */
26051
248
    } else if (IS_VAR == IS_CONST) {
26052
0
      Z_TRY_ADDREF_P(expr_ptr);
26053
248
    } else if (IS_VAR == IS_CV) {
26054
0
      ZVAL_DEREF(expr_ptr);
26055
0
      Z_TRY_ADDREF_P(expr_ptr);
26056
248
    } else /* if (IS_VAR == IS_VAR) */ {
26057
248
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
26058
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
26059
26060
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
26061
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
26062
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
26063
0
          expr_ptr = &new_expr;
26064
0
          efree_size(ref, sizeof(zend_reference));
26065
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
26066
0
          Z_ADDREF_P(expr_ptr);
26067
0
        }
26068
0
      }
26069
248
    }
26070
248
  }
26071
26072
248
  if (IS_CONST != IS_UNUSED) {
26073
248
    zval *offset = RT_CONSTANT(opline, opline->op2);
26074
248
    zend_string *str;
26075
248
    zend_ulong hval;
26076
26077
248
add_again:
26078
248
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
26079
223
      str = Z_STR_P(offset);
26080
223
      if (IS_CONST != IS_CONST) {
26081
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
26082
0
          goto num_index;
26083
0
        }
26084
0
      }
26085
223
str_index:
26086
223
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
26087
223
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
26088
25
      hval = Z_LVAL_P(offset);
26089
25
num_index:
26090
25
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
26091
25
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
26092
0
      offset = Z_REFVAL_P(offset);
26093
0
      goto add_again;
26094
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
26095
0
      str = ZSTR_EMPTY_ALLOC();
26096
0
      goto str_index;
26097
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
26098
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
26099
0
      goto num_index;
26100
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
26101
0
      hval = 0;
26102
0
      goto num_index;
26103
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
26104
0
      hval = 1;
26105
0
      goto num_index;
26106
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
26107
0
      zend_use_resource_as_offset(offset);
26108
0
      hval = Z_RES_HANDLE_P(offset);
26109
0
      goto num_index;
26110
0
    } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
26111
0
      ZVAL_UNDEFINED_OP2();
26112
0
      str = ZSTR_EMPTY_ALLOC();
26113
0
      goto str_index;
26114
0
    } else {
26115
0
      zend_illegal_array_offset_access(offset);
26116
0
      zval_ptr_dtor_nogc(expr_ptr);
26117
0
    }
26118
26119
248
  } else {
26120
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
26121
0
      zend_cannot_add_element();
26122
0
      zval_ptr_dtor_nogc(expr_ptr);
26123
0
    }
26124
0
  }
26125
248
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26126
248
}
26127
26128
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26129
133
{
26130
133
  zval *array;
26131
133
  uint32_t size;
26132
133
  USE_OPLINE
26133
26134
133
  SAVE_OPLINE();
26135
133
  array = EX_VAR(opline->result.var);
26136
133
  if (IS_VAR != IS_UNUSED) {
26137
133
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
26138
133
    ZVAL_ARR(array, zend_new_array(size));
26139
    /* Explicitly initialize array as not-packed if flag is set */
26140
133
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
26141
123
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
26142
123
    }
26143
133
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26144
133
  } else {
26145
0
    ZVAL_ARR(array, zend_new_array(0));
26146
0
    ZEND_VM_NEXT_OPCODE();
26147
0
  }
26148
133
}
26149
26150
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26151
169
{
26152
169
  USE_OPLINE
26153
169
  zval *container;
26154
169
  zval *offset;
26155
169
  zend_ulong hval;
26156
169
  zend_string *key;
26157
26158
169
  SAVE_OPLINE();
26159
169
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26160
169
  offset = RT_CONSTANT(opline, opline->op2);
26161
26162
169
  do {
26163
169
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26164
68
      HashTable *ht;
26165
26166
68
unset_dim_array:
26167
68
      SEPARATE_ARRAY(container);
26168
68
      ht = Z_ARRVAL_P(container);
26169
68
offset_again:
26170
68
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
26171
29
        key = Z_STR_P(offset);
26172
29
        if (IS_CONST != IS_CONST) {
26173
0
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
26174
0
            goto num_index_dim;
26175
0
          }
26176
0
        }
26177
29
str_index_dim:
26178
29
        ZEND_ASSERT(ht != &EG(symbol_table));
26179
29
        zend_hash_del(ht, key);
26180
39
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
26181
39
        hval = Z_LVAL_P(offset);
26182
39
num_index_dim:
26183
39
        zend_hash_index_del(ht, hval);
26184
39
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
26185
0
        offset = Z_REFVAL_P(offset);
26186
0
        goto offset_again;
26187
0
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
26188
0
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
26189
0
        goto num_index_dim;
26190
0
      } else if (Z_TYPE_P(offset) == IS_NULL) {
26191
0
        key = ZSTR_EMPTY_ALLOC();
26192
0
        goto str_index_dim;
26193
0
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
26194
0
        hval = 0;
26195
0
        goto num_index_dim;
26196
0
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
26197
0
        hval = 1;
26198
0
        goto num_index_dim;
26199
0
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
26200
0
        zend_use_resource_as_offset(offset);
26201
0
        hval = Z_RES_HANDLE_P(offset);
26202
0
        goto num_index_dim;
26203
0
      } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
26204
0
        ZVAL_UNDEFINED_OP2();
26205
0
        key = ZSTR_EMPTY_ALLOC();
26206
0
        goto str_index_dim;
26207
0
      } else {
26208
0
        zend_illegal_array_offset_unset(offset);
26209
0
      }
26210
68
      break;
26211
101
    } else if (Z_ISREF_P(container)) {
26212
0
      container = Z_REFVAL_P(container);
26213
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26214
0
        goto unset_dim_array;
26215
0
      }
26216
0
    }
26217
101
    if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
26218
0
      container = ZVAL_UNDEFINED_OP1();
26219
0
    }
26220
101
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
26221
0
      offset = ZVAL_UNDEFINED_OP2();
26222
0
    }
26223
101
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26224
21
      if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
26225
0
        offset++;
26226
0
      }
26227
21
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
26228
80
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
26229
0
      zend_throw_error(NULL, "Cannot unset string offsets");
26230
80
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
26231
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
26232
80
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
26233
0
      zend_false_to_array_deprecated();
26234
0
    }
26235
101
  } while (0);
26236
26237
169
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26238
169
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26239
169
}
26240
26241
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26242
43
{
26243
43
  USE_OPLINE
26244
43
  zval *container;
26245
43
  zval *offset;
26246
43
  zend_string *name, *tmp_name;
26247
26248
43
  SAVE_OPLINE();
26249
43
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26250
43
  offset = RT_CONSTANT(opline, opline->op2);
26251
26252
43
  do {
26253
43
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
26254
29
      if (Z_ISREF_P(container)) {
26255
0
        container = Z_REFVAL_P(container);
26256
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
26257
0
          if (IS_VAR == IS_CV
26258
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
26259
0
            ZVAL_UNDEFINED_OP1();
26260
0
          }
26261
0
          break;
26262
0
        }
26263
29
      } else {
26264
29
        break;
26265
29
      }
26266
29
    }
26267
14
    if (IS_CONST == IS_CONST) {
26268
14
      name = Z_STR_P(offset);
26269
14
    } else {
26270
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
26271
0
      if (UNEXPECTED(!name)) {
26272
0
        break;
26273
0
      }
26274
0
    }
26275
14
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
26276
14
    if (IS_CONST != IS_CONST) {
26277
0
      zend_tmp_string_release(tmp_name);
26278
0
    }
26279
14
  } while (0);
26280
26281
43
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26282
43
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26283
43
}
26284
26285
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26286
38
{
26287
38
  USE_OPLINE
26288
26289
38
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
26290
26291
38
  SAVE_OPLINE();
26292
38
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
26293
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26294
0
  }
26295
26296
  /* Destroy the previously yielded value */
26297
38
  zval_ptr_dtor(&generator->value);
26298
26299
  /* Destroy the previously yielded key */
26300
38
  zval_ptr_dtor(&generator->key);
26301
26302
  /* Set the new yielded value */
26303
38
  if (IS_VAR != IS_UNUSED) {
26304
38
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
26305
      /* Constants and temporary variables aren't yieldable by reference,
26306
       * but we still allow them with a notice. */
26307
0
      if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
26308
0
        zval *value;
26309
26310
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26311
26312
0
        value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26313
0
        ZVAL_COPY_VALUE(&generator->value, value);
26314
0
        if (IS_VAR == IS_CONST) {
26315
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
26316
0
            Z_ADDREF(generator->value);
26317
0
          }
26318
0
        }
26319
0
      } else {
26320
0
        zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26321
26322
        /* If a function call result is yielded and the function did
26323
         * not return by reference we throw a notice. */
26324
0
        do {
26325
0
          if (IS_VAR == IS_VAR) {
26326
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
26327
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
26328
0
             && !Z_ISREF_P(value_ptr)) {
26329
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26330
0
              ZVAL_COPY(&generator->value, value_ptr);
26331
0
              break;
26332
0
            }
26333
0
          }
26334
0
          if (Z_ISREF_P(value_ptr)) {
26335
0
            Z_ADDREF_P(value_ptr);
26336
0
          } else {
26337
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
26338
0
          }
26339
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
26340
0
        } while (0);
26341
26342
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26343
0
      }
26344
38
    } else {
26345
38
      zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26346
26347
      /* Consts, temporary variables and references need copying */
26348
38
      if (IS_VAR == IS_CONST) {
26349
0
        ZVAL_COPY_VALUE(&generator->value, value);
26350
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
26351
0
          Z_ADDREF(generator->value);
26352
0
        }
26353
38
      } else if (IS_VAR == IS_TMP_VAR) {
26354
0
        ZVAL_COPY_VALUE(&generator->value, value);
26355
38
      } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
26356
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
26357
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26358
38
      } else {
26359
38
        ZVAL_COPY_VALUE(&generator->value, value);
26360
38
        if (IS_VAR == IS_CV) {
26361
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
26362
0
        }
26363
38
      }
26364
38
    }
26365
38
  } else {
26366
    /* If no value was specified yield null */
26367
0
    ZVAL_NULL(&generator->value);
26368
0
  }
26369
26370
  /* Set the new yielded key */
26371
38
  if (IS_CONST != IS_UNUSED) {
26372
38
    zval *key = RT_CONSTANT(opline, opline->op2);
26373
38
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
26374
0
      key = Z_REFVAL_P(key);
26375
0
    }
26376
38
    ZVAL_COPY(&generator->key, key);
26377
26378
38
    if (Z_TYPE(generator->key) == IS_LONG
26379
38
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
26380
38
    ) {
26381
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
26382
0
    }
26383
38
  } else {
26384
    /* If no key was specified we use auto-increment keys */
26385
0
    generator->largest_used_integer_key++;
26386
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
26387
0
  }
26388
26389
38
  if (RETURN_VALUE_USED(opline)) {
26390
    /* If the return value of yield is used set the send
26391
     * target and initialize it to NULL */
26392
38
    generator->send_target = EX_VAR(opline->result.var);
26393
38
    ZVAL_NULL(generator->send_target);
26394
38
  } else {
26395
0
    generator->send_target = NULL;
26396
0
  }
26397
26398
  /* The GOTO VM uses a local opline variable. We need to set the opline
26399
   * variable in execute_data so we don't resume at an old position. */
26400
38
  SAVE_OPLINE();
26401
26402
38
  ZEND_VM_RETURN();
26403
38
}
26404
26405
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26406
0
{
26407
0
  USE_OPLINE
26408
0
  zval *op1;
26409
0
  HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
26410
0
  zval *result;
26411
26412
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26413
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26414
0
    result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_VAR == IS_CONST);
26415
0
    if (IS_VAR & (IS_TMP_VAR|IS_VAR)) {
26416
0
      zval_ptr_dtor_str(op1);
26417
0
    }
26418
0
    ZEND_VM_SMART_BRANCH(result, 0);
26419
0
  }
26420
26421
0
  if (opline->extended_value) {
26422
0
    if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
26423
0
      result = zend_hash_index_find(ht, Z_LVAL_P(op1));
26424
0
      ZEND_VM_SMART_BRANCH(result, 0);
26425
0
    }
26426
0
    SAVE_OPLINE();
26427
0
    if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
26428
0
      op1 = Z_REFVAL_P(op1);
26429
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26430
0
        result = zend_hash_find(ht, Z_STR_P(op1));
26431
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26432
0
        ZEND_VM_SMART_BRANCH(result, 0);
26433
0
      } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
26434
0
        result = zend_hash_index_find(ht, Z_LVAL_P(op1));
26435
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26436
0
        ZEND_VM_SMART_BRANCH(result, 0);
26437
0
      }
26438
0
    } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
26439
0
      ZVAL_UNDEFINED_OP1();
26440
0
    }
26441
0
  } else if (Z_TYPE_P(op1) <= IS_FALSE) {
26442
0
    if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
26443
0
      SAVE_OPLINE();
26444
0
      ZVAL_UNDEFINED_OP1();
26445
0
      if (UNEXPECTED(EG(exception) != NULL)) {
26446
0
        HANDLE_EXCEPTION();
26447
0
      }
26448
0
    }
26449
0
    result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
26450
0
    ZEND_VM_SMART_BRANCH(result, 0);
26451
0
  } else {
26452
0
    zend_string *key;
26453
0
    zval key_tmp;
26454
26455
0
    if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
26456
0
      op1 = Z_REFVAL_P(op1);
26457
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26458
0
        result = zend_hash_find(ht, Z_STR_P(op1));
26459
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26460
0
        ZEND_VM_SMART_BRANCH(result, 0);
26461
0
      }
26462
0
    }
26463
26464
0
    SAVE_OPLINE();
26465
0
    ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
26466
0
      ZVAL_STR(&key_tmp, key);
26467
0
      if (zend_compare(op1, &key_tmp) == 0) {
26468
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26469
0
        ZEND_VM_SMART_BRANCH(1, 1);
26470
0
      }
26471
0
    } ZEND_HASH_FOREACH_END();
26472
0
  }
26473
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26474
0
  ZEND_VM_SMART_BRANCH(0, 1);
26475
0
}
26476
26477
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26478
141
{
26479
141
  zend_class_entry *ce, *scope;
26480
141
  zend_class_constant *c;
26481
141
  zval *value, *zv, *constant_zv;
26482
141
  zend_string *constant_name;
26483
141
  USE_OPLINE
26484
26485
141
  SAVE_OPLINE();
26486
26487
141
  do {
26488
141
    if (IS_VAR == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
26489
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
26490
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
26491
0
        break;
26492
0
      }
26493
0
    }
26494
141
    if (IS_VAR == IS_CONST) {
26495
0
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
26496
0
        ce = CACHED_PTR(opline->extended_value);
26497
0
      } else {
26498
0
        ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
26499
0
        if (UNEXPECTED(ce == NULL)) {
26500
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26501
0
          FREE_OP(opline->op2_type, opline->op2.var);
26502
0
          HANDLE_EXCEPTION();
26503
0
        }
26504
0
        CACHE_PTR(opline->extended_value, ce);
26505
0
      }
26506
141
    } else if (IS_VAR == IS_UNUSED) {
26507
0
      ce = zend_fetch_class(NULL, opline->op1.num);
26508
0
      if (UNEXPECTED(ce == NULL)) {
26509
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
26510
0
        FREE_OP(opline->op2_type, opline->op2.var);
26511
0
        HANDLE_EXCEPTION();
26512
0
      }
26513
141
    } else {
26514
141
      ce = Z_CE_P(EX_VAR(opline->op1.var));
26515
141
    }
26516
141
    if (IS_VAR != IS_CONST
26517
141
      && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
26518
141
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
26519
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
26520
0
      break;
26521
0
    }
26522
26523
141
    constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
26524
141
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
26525
62
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
26526
62
      ZVAL_UNDEF(EX_VAR(opline->result.var));
26527
62
      FREE_OP(opline->op2_type, opline->op2.var);
26528
62
      HANDLE_EXCEPTION();
26529
62
    }
26530
79
    constant_name = Z_STR_P(constant_zv);
26531
    /* Magic 'class' for constant OP2 is caught at compile-time */
26532
79
    if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
26533
21
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
26534
21
      FREE_OP(opline->op2_type, opline->op2.var);
26535
21
      ZEND_VM_NEXT_OPCODE();
26536
21
    }
26537
58
    zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
26538
58
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
26539
58
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
26540
26541
58
    if (EXPECTED(zv != NULL)) {
26542
41
      c = Z_PTR_P(zv);
26543
41
      scope = EX(func)->op_array.scope;
26544
41
      if (!zend_verify_const_access(c, scope)) {
26545
0
        zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26546
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
26547
0
        FREE_OP(opline->op2_type, opline->op2.var);
26548
0
        HANDLE_EXCEPTION();
26549
0
      }
26550
26551
41
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
26552
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26553
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
26554
0
        FREE_OP(opline->op2_type, opline->op2.var);
26555
0
        HANDLE_EXCEPTION();
26556
0
      }
26557
26558
41
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
26559
41
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
26560
0
        if (c->ce->type == ZEND_USER_CLASS) {
26561
          /* Recursion protection only applied to user constants, GH-18463 */
26562
0
          CONST_PROTECT_RECURSION(c);
26563
0
        }
26564
0
        zend_deprecated_class_constant(c, constant_name);
26565
0
        if (c->ce->type == ZEND_USER_CLASS) {
26566
0
          CONST_UNPROTECT_RECURSION(c);
26567
0
        }
26568
26569
0
        if (EG(exception)) {
26570
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26571
0
          FREE_OP(opline->op2_type, opline->op2.var);
26572
0
          HANDLE_EXCEPTION();
26573
0
        }
26574
0
      }
26575
26576
41
      value = &c->value;
26577
      // Enums require loading of all class constants to build the backed enum table
26578
41
      if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
26579
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
26580
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26581
0
          FREE_OP(opline->op2_type, opline->op2.var);
26582
0
          HANDLE_EXCEPTION();
26583
0
        }
26584
0
      }
26585
41
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
26586
0
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
26587
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26588
0
          FREE_OP(opline->op2_type, opline->op2.var);
26589
0
          HANDLE_EXCEPTION();
26590
0
        }
26591
0
      }
26592
41
      if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
26593
0
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
26594
0
      }
26595
41
    } else {
26596
17
      zend_throw_error(NULL, "Undefined constant %s::%s",
26597
17
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26598
17
      ZVAL_UNDEF(EX_VAR(opline->result.var));
26599
17
      FREE_OP(opline->op2_type, opline->op2.var);
26600
17
      HANDLE_EXCEPTION();
26601
17
    }
26602
58
  } while (0);
26603
26604
41
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
26605
26606
41
  FREE_OP(opline->op2_type, opline->op2.var);
26607
41
  ZEND_VM_NEXT_OPCODE();
26608
41
}
26609
26610
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26611
0
{
26612
0
  USE_OPLINE
26613
0
  zval *object;
26614
0
  zval *property;
26615
0
  zval *value;
26616
0
  zval *zptr;
26617
0
  void *_cache_slot[3] = {0};
26618
0
  void **cache_slot;
26619
0
  zend_property_info *prop_info;
26620
0
  zend_object *zobj;
26621
0
  zend_string *name, *tmp_name;
26622
26623
0
  SAVE_OPLINE();
26624
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26625
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26626
26627
0
  do {
26628
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26629
26630
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26631
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26632
0
        object = Z_REFVAL_P(object);
26633
0
        goto assign_op_object;
26634
0
      }
26635
0
      if (IS_VAR == IS_CV
26636
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26637
0
        ZVAL_UNDEFINED_OP1();
26638
0
      }
26639
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26640
0
      break;
26641
0
    }
26642
26643
0
assign_op_object:
26644
    /* here we are sure we are dealing with an object */
26645
0
    zobj = Z_OBJ_P(object);
26646
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26647
0
      name = Z_STR_P(property);
26648
0
    } else {
26649
0
      name = zval_try_get_tmp_string(property, &tmp_name);
26650
0
      if (UNEXPECTED(!name)) {
26651
0
        UNDEF_RESULT();
26652
0
        break;
26653
0
      }
26654
0
    }
26655
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
26656
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26657
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26658
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26659
0
          ZVAL_NULL(EX_VAR(opline->result.var));
26660
0
        }
26661
0
      } else {
26662
0
        zend_reference *ref;
26663
26664
0
        do {
26665
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
26666
0
            ref = Z_REF_P(zptr);
26667
0
            zptr = Z_REFVAL_P(zptr);
26668
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26669
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26670
0
              break;
26671
0
            }
26672
0
          }
26673
26674
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26675
0
          if (prop_info) {
26676
            /* special case for typed properties */
26677
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
26678
0
          } else {
26679
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
26680
0
          }
26681
0
        } while (0);
26682
26683
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26684
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
26685
0
        }
26686
0
      }
26687
0
    } else {
26688
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
26689
0
    }
26690
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26691
0
      zend_tmp_string_release(tmp_name);
26692
0
    }
26693
0
  } while (0);
26694
26695
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26696
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26697
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26698
  /* assign_obj has two opcodes! */
26699
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
26700
0
}
26701
26702
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
26703
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26704
390
{
26705
390
  USE_OPLINE
26706
390
  zval *var_ptr;
26707
390
  zval *value, *container, *dim;
26708
390
  HashTable *ht;
26709
26710
390
  SAVE_OPLINE();
26711
390
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26712
26713
390
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26714
113
assign_dim_op_array:
26715
113
    SEPARATE_ARRAY(container);
26716
113
    ht = Z_ARRVAL_P(container);
26717
390
assign_dim_op_new_array:
26718
390
    dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26719
390
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26720
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
26721
0
      if (UNEXPECTED(!var_ptr)) {
26722
0
        zend_cannot_add_element();
26723
0
        goto assign_dim_op_ret_null;
26724
0
      }
26725
390
    } else {
26726
390
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26727
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
26728
390
      } else {
26729
390
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
26730
390
      }
26731
390
      if (UNEXPECTED(!var_ptr)) {
26732
0
        goto assign_dim_op_ret_null;
26733
0
      }
26734
390
    }
26735
26736
390
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26737
26738
390
    do {
26739
390
      if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
26740
0
        zend_reference *ref = Z_REF_P(var_ptr);
26741
0
        var_ptr = Z_REFVAL_P(var_ptr);
26742
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26743
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26744
0
          break;
26745
0
        }
26746
0
      }
26747
390
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26748
390
    } while (0);
26749
26750
390
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26751
219
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26752
219
    }
26753
390
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26754
390
  } else {
26755
277
    if (EXPECTED(Z_ISREF_P(container))) {
26756
0
      container = Z_REFVAL_P(container);
26757
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26758
0
        goto assign_dim_op_array;
26759
0
      }
26760
0
    }
26761
26762
277
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26763
0
      zend_object *obj = Z_OBJ_P(container);
26764
26765
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26766
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
26767
0
        dim++;
26768
0
      }
26769
0
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
26770
277
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
26771
277
      uint8_t old_type;
26772
26773
277
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
26774
0
        ZVAL_UNDEFINED_OP1();
26775
0
      }
26776
277
      ht = zend_new_array(8);
26777
277
      old_type = Z_TYPE_P(container);
26778
277
      ZVAL_ARR(container, ht);
26779
277
      if (UNEXPECTED(old_type == IS_FALSE)) {
26780
0
        GC_ADDREF(ht);
26781
0
        zend_false_to_array_deprecated();
26782
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
26783
0
          zend_array_destroy(ht);
26784
0
          goto assign_dim_op_ret_null;
26785
0
        }
26786
0
      }
26787
277
      goto assign_dim_op_new_array;
26788
277
    } else {
26789
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26790
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
26791
0
assign_dim_op_ret_null:
26792
0
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26793
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26794
0
        ZVAL_NULL(EX_VAR(opline->result.var));
26795
0
      }
26796
0
    }
26797
277
  }
26798
26799
390
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26800
390
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26801
390
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
26802
390
}
26803
26804
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26805
6.36k
{
26806
6.36k
  USE_OPLINE
26807
6.36k
  zval *var_ptr;
26808
6.36k
  zval *value;
26809
26810
6.36k
  SAVE_OPLINE();
26811
6.36k
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26812
6.36k
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26813
26814
6.36k
  do {
26815
6.36k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
26816
220
      zend_reference *ref = Z_REF_P(var_ptr);
26817
220
      var_ptr = Z_REFVAL_P(var_ptr);
26818
220
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26819
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26820
0
        break;
26821
0
      }
26822
220
    }
26823
6.36k
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26824
6.36k
  } while (0);
26825
26826
6.36k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26827
5.46k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26828
5.46k
  }
26829
26830
6.36k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26831
6.36k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26832
6.36k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26833
6.36k
}
26834
26835
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26836
0
{
26837
0
  USE_OPLINE
26838
0
  zval *object;
26839
0
  zval *property;
26840
0
  zval *zptr;
26841
0
  void *_cache_slot[3] = {0};
26842
0
  void **cache_slot;
26843
0
  zend_property_info *prop_info;
26844
0
  zend_object *zobj;
26845
0
  zend_string *name, *tmp_name;
26846
26847
0
  SAVE_OPLINE();
26848
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26849
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26850
26851
0
  do {
26852
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26853
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26854
0
        object = Z_REFVAL_P(object);
26855
0
        goto pre_incdec_object;
26856
0
      }
26857
0
      if (IS_VAR == IS_CV
26858
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26859
0
        ZVAL_UNDEFINED_OP1();
26860
0
      }
26861
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26862
0
      break;
26863
0
    }
26864
26865
0
pre_incdec_object:
26866
    /* here we are sure we are dealing with an object */
26867
0
    zobj = Z_OBJ_P(object);
26868
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26869
0
      name = Z_STR_P(property);
26870
0
    } else {
26871
0
      name = zval_try_get_tmp_string(property, &tmp_name);
26872
0
      if (UNEXPECTED(!name)) {
26873
0
        UNDEF_RESULT();
26874
0
        break;
26875
0
      }
26876
0
    }
26877
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
26878
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26879
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26880
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26881
0
          ZVAL_NULL(EX_VAR(opline->result.var));
26882
0
        }
26883
0
      } else {
26884
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
26885
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26886
0
      }
26887
0
    } else {
26888
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26889
0
    }
26890
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26891
0
      zend_tmp_string_release(tmp_name);
26892
0
    }
26893
0
  } while (0);
26894
26895
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26896
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26897
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26898
0
}
26899
26900
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26901
0
{
26902
0
  USE_OPLINE
26903
0
  zval *object;
26904
0
  zval *property;
26905
0
  zval *zptr;
26906
0
  void *_cache_slot[3] = {0};
26907
0
  void **cache_slot;
26908
0
  zend_property_info *prop_info;
26909
0
  zend_object *zobj;
26910
0
  zend_string *name, *tmp_name;
26911
26912
0
  SAVE_OPLINE();
26913
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26914
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26915
26916
0
  do {
26917
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26918
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26919
0
        object = Z_REFVAL_P(object);
26920
0
        goto post_incdec_object;
26921
0
      }
26922
0
      if (IS_VAR == IS_CV
26923
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26924
0
        ZVAL_UNDEFINED_OP1();
26925
0
      }
26926
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26927
0
      break;
26928
0
    }
26929
26930
0
post_incdec_object:
26931
    /* here we are sure we are dealing with an object */
26932
0
    zobj = Z_OBJ_P(object);
26933
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26934
0
      name = Z_STR_P(property);
26935
0
    } else {
26936
0
      name = zval_try_get_tmp_string(property, &tmp_name);
26937
0
      if (UNEXPECTED(!name)) {
26938
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
26939
0
        break;
26940
0
      }
26941
0
    }
26942
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
26943
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26944
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26945
0
        ZVAL_NULL(EX_VAR(opline->result.var));
26946
0
      } else {
26947
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26948
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26949
0
      }
26950
0
    } else {
26951
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26952
0
    }
26953
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26954
0
      zend_tmp_string_release(tmp_name);
26955
0
    }
26956
0
  } while (0);
26957
26958
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26959
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26960
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26961
0
}
26962
26963
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26964
126
{
26965
126
  USE_OPLINE
26966
126
  zval *container;
26967
26968
126
  SAVE_OPLINE();
26969
126
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26970
126
  zend_fetch_dimension_address_W(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
26971
126
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26972
126
  if (IS_VAR == IS_VAR) {
26973
126
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26974
126
  }
26975
126
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26976
126
}
26977
26978
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26979
258
{
26980
258
  USE_OPLINE
26981
258
  zval *container;
26982
26983
258
  SAVE_OPLINE();
26984
258
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26985
258
  zend_fetch_dimension_address_RW(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
26986
258
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26987
258
  if (IS_VAR == IS_VAR) {
26988
258
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26989
258
  }
26990
258
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26991
258
}
26992
26993
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26994
0
{
26995
#if 0
26996
  USE_OPLINE
26997
#endif
26998
26999
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
27000
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
27001
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27002
0
    }
27003
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27004
0
  } else {
27005
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27006
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27007
0
    }
27008
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27009
0
  }
27010
0
}
27011
27012
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27013
17
{
27014
17
  USE_OPLINE
27015
17
  zval *container;
27016
27017
17
  SAVE_OPLINE();
27018
17
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27019
17
  zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
27020
17
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27021
17
  if (IS_VAR == IS_VAR) {
27022
17
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
27023
17
  }
27024
17
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27025
17
}
27026
27027
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27028
0
{
27029
0
  USE_OPLINE
27030
0
  zval *property, *container, *result;
27031
27032
0
  SAVE_OPLINE();
27033
27034
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27035
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27036
0
  result = EX_VAR(opline->result.var);
27037
0
  zend_fetch_property_address(
27038
0
    result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR),
27039
0
    (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
27040
0
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
27041
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27042
0
  if (IS_VAR == IS_VAR) {
27043
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
27044
0
  }
27045
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27046
0
}
27047
27048
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27049
0
{
27050
0
  USE_OPLINE
27051
0
  zval *property, *container, *result;
27052
27053
0
  SAVE_OPLINE();
27054
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27055
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27056
0
  result = EX_VAR(opline->result.var);
27057
0
  zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
27058
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27059
0
  if (IS_VAR == IS_VAR) {
27060
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
27061
0
  }
27062
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27063
0
}
27064
27065
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27066
0
{
27067
#if 0
27068
  USE_OPLINE
27069
#endif
27070
27071
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
27072
    /* Behave like FETCH_OBJ_W */
27073
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
27074
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27075
0
    }
27076
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27077
0
  } else {
27078
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27079
0
  }
27080
0
}
27081
27082
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27083
0
{
27084
0
  USE_OPLINE
27085
0
  zval *container, *property, *result;
27086
27087
0
  SAVE_OPLINE();
27088
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27089
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27090
0
  result = EX_VAR(opline->result.var);
27091
0
  zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
27092
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27093
0
  if (IS_VAR == IS_VAR) {
27094
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
27095
0
  }
27096
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27097
0
}
27098
27099
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27100
12
{
27101
12
  USE_OPLINE
27102
12
  zval *container, *dim;
27103
27104
12
  SAVE_OPLINE();
27105
12
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27106
12
  dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27107
27108
12
  if (IS_VAR == IS_VAR
27109
12
    && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
27110
12
    && UNEXPECTED(!Z_ISREF_P(container))
27111
12
  ) {
27112
0
    zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
27113
0
    zend_fetch_dimension_address_LIST_r(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
27114
12
  } else {
27115
12
    zend_fetch_dimension_address_W(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
27116
12
  }
27117
27118
12
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27119
12
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27120
12
}
27121
27122
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27123
7
{
27124
7
  USE_OPLINE
27125
7
  zval *object, *value, tmp;
27126
7
  zend_object *zobj;
27127
7
  zend_string *name, *tmp_name;
27128
7
  zend_refcounted *garbage = NULL;
27129
27130
7
  SAVE_OPLINE();
27131
7
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27132
7
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
27133
27134
7
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27135
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27136
0
      object = Z_REFVAL_P(object);
27137
0
      goto assign_object;
27138
0
    }
27139
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27140
0
    value = &EG(uninitialized_zval);
27141
0
    goto free_and_exit_assign_obj;
27142
0
  }
27143
27144
7
assign_object:
27145
7
  zobj = Z_OBJ_P(object);
27146
7
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27147
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27148
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
27149
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27150
0
      zval *property_val;
27151
0
      zend_property_info *prop_info;
27152
27153
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27154
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27155
27156
0
assign_obj_simple:
27157
0
        property_val = OBJ_PROP(zobj, prop_offset);
27158
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
27159
0
          if (prop_info != NULL) {
27160
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27161
0
            goto free_and_exit_assign_obj;
27162
0
          } else {
27163
0
fast_assign_obj:
27164
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27165
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27166
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
27167
0
            }
27168
0
            goto exit_assign_obj;
27169
0
          }
27170
0
        }
27171
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27172
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27173
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27174
0
          zobj = zend_lazy_object_init(zobj);
27175
0
          if (!zobj) {
27176
0
            value = &EG(uninitialized_zval);
27177
0
            goto free_and_exit_assign_obj;
27178
0
          }
27179
0
        }
27180
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27181
0
          rebuild_object_properties_internal(zobj);
27182
0
        }
27183
0
        if (EXPECTED(zobj->properties != NULL)) {
27184
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27185
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27186
0
              GC_DELREF(zobj->properties);
27187
0
            }
27188
0
            zobj->properties = zend_array_dup(zobj->properties);
27189
0
          }
27190
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
27191
0
          if (property_val) {
27192
0
            goto fast_assign_obj;
27193
0
          }
27194
0
        }
27195
27196
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27197
0
          if (IS_CONST == IS_CONST) {
27198
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27199
0
              Z_ADDREF_P(value);
27200
0
            }
27201
0
          } else if (IS_CONST != IS_TMP_VAR) {
27202
0
            if (Z_ISREF_P(value)) {
27203
0
              if (IS_CONST == IS_VAR) {
27204
0
                zend_reference *ref = Z_REF_P(value);
27205
0
                if (GC_DELREF(ref) == 0) {
27206
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27207
0
                  efree_size(ref, sizeof(zend_reference));
27208
0
                  value = &tmp;
27209
0
                } else {
27210
0
                  value = Z_REFVAL_P(value);
27211
0
                  Z_TRY_ADDREF_P(value);
27212
0
                }
27213
0
              } else {
27214
0
                value = Z_REFVAL_P(value);
27215
0
                Z_TRY_ADDREF_P(value);
27216
0
              }
27217
0
            } else if (IS_CONST == IS_CV) {
27218
0
              Z_TRY_ADDREF_P(value);
27219
0
            }
27220
0
          }
27221
0
          zend_hash_add_new(zobj->properties, name, value);
27222
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27223
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
27224
0
          }
27225
0
          goto exit_assign_obj;
27226
0
        }
27227
0
      } else {
27228
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27229
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27230
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
27231
0
          prop_offset = prop_info->offset;
27232
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27233
0
            prop_info = NULL;
27234
0
          }
27235
0
          goto assign_obj_simple;
27236
0
        }
27237
        /* Fall through to write_property for hooks. */
27238
0
      }
27239
0
    }
27240
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27241
7
  } else {
27242
7
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27243
7
    if (UNEXPECTED(!name)) {
27244
27245
0
      UNDEF_RESULT();
27246
0
      goto exit_assign_obj;
27247
0
    }
27248
7
  }
27249
27250
7
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
27251
0
    ZVAL_DEREF(value);
27252
0
  }
27253
27254
7
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27255
27256
7
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27257
7
    zend_tmp_string_release(tmp_name);
27258
7
  }
27259
27260
7
free_and_exit_assign_obj:
27261
7
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27262
7
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27263
7
  }
27264
27265
7
exit_assign_obj:
27266
7
  if (garbage) {
27267
0
    GC_DTOR_NO_REF(garbage);
27268
0
  }
27269
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27270
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27271
  /* assign_obj has two opcodes! */
27272
7
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27273
7
}
27274
27275
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27276
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27277
0
{
27278
0
  USE_OPLINE
27279
0
  zval *object, *value, tmp;
27280
0
  zend_object *zobj;
27281
0
  zend_string *name, *tmp_name;
27282
0
  zend_refcounted *garbage = NULL;
27283
27284
0
  SAVE_OPLINE();
27285
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27286
0
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27287
27288
0
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27289
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27290
0
      object = Z_REFVAL_P(object);
27291
0
      goto assign_object;
27292
0
    }
27293
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27294
0
    value = &EG(uninitialized_zval);
27295
0
    goto free_and_exit_assign_obj;
27296
0
  }
27297
27298
0
assign_object:
27299
0
  zobj = Z_OBJ_P(object);
27300
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27301
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27302
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
27303
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27304
0
      zval *property_val;
27305
0
      zend_property_info *prop_info;
27306
27307
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27308
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27309
27310
0
assign_obj_simple:
27311
0
        property_val = OBJ_PROP(zobj, prop_offset);
27312
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
27313
0
          if (prop_info != NULL) {
27314
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27315
0
            goto free_and_exit_assign_obj;
27316
0
          } else {
27317
0
fast_assign_obj:
27318
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27319
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27320
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
27321
0
            }
27322
0
            goto exit_assign_obj;
27323
0
          }
27324
0
        }
27325
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27326
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27327
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27328
0
          zobj = zend_lazy_object_init(zobj);
27329
0
          if (!zobj) {
27330
0
            value = &EG(uninitialized_zval);
27331
0
            goto free_and_exit_assign_obj;
27332
0
          }
27333
0
        }
27334
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27335
0
          rebuild_object_properties_internal(zobj);
27336
0
        }
27337
0
        if (EXPECTED(zobj->properties != NULL)) {
27338
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27339
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27340
0
              GC_DELREF(zobj->properties);
27341
0
            }
27342
0
            zobj->properties = zend_array_dup(zobj->properties);
27343
0
          }
27344
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
27345
0
          if (property_val) {
27346
0
            goto fast_assign_obj;
27347
0
          }
27348
0
        }
27349
27350
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27351
0
          if (IS_TMP_VAR == IS_CONST) {
27352
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27353
0
              Z_ADDREF_P(value);
27354
0
            }
27355
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
27356
0
            if (Z_ISREF_P(value)) {
27357
0
              if (IS_TMP_VAR == IS_VAR) {
27358
0
                zend_reference *ref = Z_REF_P(value);
27359
0
                if (GC_DELREF(ref) == 0) {
27360
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27361
0
                  efree_size(ref, sizeof(zend_reference));
27362
0
                  value = &tmp;
27363
0
                } else {
27364
0
                  value = Z_REFVAL_P(value);
27365
0
                  Z_TRY_ADDREF_P(value);
27366
0
                }
27367
0
              } else {
27368
0
                value = Z_REFVAL_P(value);
27369
0
                Z_TRY_ADDREF_P(value);
27370
0
              }
27371
0
            } else if (IS_TMP_VAR == IS_CV) {
27372
0
              Z_TRY_ADDREF_P(value);
27373
0
            }
27374
0
          }
27375
0
          zend_hash_add_new(zobj->properties, name, value);
27376
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27377
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
27378
0
          }
27379
0
          goto exit_assign_obj;
27380
0
        }
27381
0
      } else {
27382
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27383
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27384
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
27385
0
          prop_offset = prop_info->offset;
27386
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27387
0
            prop_info = NULL;
27388
0
          }
27389
0
          goto assign_obj_simple;
27390
0
        }
27391
        /* Fall through to write_property for hooks. */
27392
0
      }
27393
0
    }
27394
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27395
0
  } else {
27396
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27397
0
    if (UNEXPECTED(!name)) {
27398
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27399
0
      UNDEF_RESULT();
27400
0
      goto exit_assign_obj;
27401
0
    }
27402
0
  }
27403
27404
0
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27405
0
    ZVAL_DEREF(value);
27406
0
  }
27407
27408
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27409
27410
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27411
0
    zend_tmp_string_release(tmp_name);
27412
0
  }
27413
27414
0
free_and_exit_assign_obj:
27415
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27416
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27417
0
  }
27418
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27419
0
exit_assign_obj:
27420
0
  if (garbage) {
27421
0
    GC_DTOR_NO_REF(garbage);
27422
0
  }
27423
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27424
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27425
  /* assign_obj has two opcodes! */
27426
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27427
0
}
27428
27429
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27430
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27431
53
{
27432
53
  USE_OPLINE
27433
53
  zval *object, *value, tmp;
27434
53
  zend_object *zobj;
27435
53
  zend_string *name, *tmp_name;
27436
53
  zend_refcounted *garbage = NULL;
27437
27438
53
  SAVE_OPLINE();
27439
53
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27440
53
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27441
27442
53
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27443
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27444
0
      object = Z_REFVAL_P(object);
27445
0
      goto assign_object;
27446
0
    }
27447
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27448
0
    value = &EG(uninitialized_zval);
27449
0
    goto free_and_exit_assign_obj;
27450
0
  }
27451
27452
53
assign_object:
27453
53
  zobj = Z_OBJ_P(object);
27454
53
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27455
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27456
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
27457
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27458
0
      zval *property_val;
27459
0
      zend_property_info *prop_info;
27460
27461
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27462
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27463
27464
0
assign_obj_simple:
27465
0
        property_val = OBJ_PROP(zobj, prop_offset);
27466
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
27467
0
          if (prop_info != NULL) {
27468
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27469
0
            goto free_and_exit_assign_obj;
27470
0
          } else {
27471
0
fast_assign_obj:
27472
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
27473
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27474
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
27475
0
            }
27476
0
            goto exit_assign_obj;
27477
0
          }
27478
0
        }
27479
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27480
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27481
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27482
0
          zobj = zend_lazy_object_init(zobj);
27483
0
          if (!zobj) {
27484
0
            value = &EG(uninitialized_zval);
27485
0
            goto free_and_exit_assign_obj;
27486
0
          }
27487
0
        }
27488
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27489
0
          rebuild_object_properties_internal(zobj);
27490
0
        }
27491
0
        if (EXPECTED(zobj->properties != NULL)) {
27492
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27493
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27494
0
              GC_DELREF(zobj->properties);
27495
0
            }
27496
0
            zobj->properties = zend_array_dup(zobj->properties);
27497
0
          }
27498
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
27499
0
          if (property_val) {
27500
0
            goto fast_assign_obj;
27501
0
          }
27502
0
        }
27503
27504
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27505
0
          if (IS_VAR == IS_CONST) {
27506
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27507
0
              Z_ADDREF_P(value);
27508
0
            }
27509
0
          } else if (IS_VAR != IS_TMP_VAR) {
27510
0
            if (Z_ISREF_P(value)) {
27511
0
              if (IS_VAR == IS_VAR) {
27512
0
                zend_reference *ref = Z_REF_P(value);
27513
0
                if (GC_DELREF(ref) == 0) {
27514
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27515
0
                  efree_size(ref, sizeof(zend_reference));
27516
0
                  value = &tmp;
27517
0
                } else {
27518
0
                  value = Z_REFVAL_P(value);
27519
0
                  Z_TRY_ADDREF_P(value);
27520
0
                }
27521
0
              } else {
27522
0
                value = Z_REFVAL_P(value);
27523
0
                Z_TRY_ADDREF_P(value);
27524
0
              }
27525
0
            } else if (IS_VAR == IS_CV) {
27526
0
              Z_TRY_ADDREF_P(value);
27527
0
            }
27528
0
          }
27529
0
          zend_hash_add_new(zobj->properties, name, value);
27530
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27531
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
27532
0
          }
27533
0
          goto exit_assign_obj;
27534
0
        }
27535
0
      } else {
27536
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27537
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27538
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
27539
0
          prop_offset = prop_info->offset;
27540
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27541
0
            prop_info = NULL;
27542
0
          }
27543
0
          goto assign_obj_simple;
27544
0
        }
27545
        /* Fall through to write_property for hooks. */
27546
0
      }
27547
0
    }
27548
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27549
53
  } else {
27550
53
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27551
53
    if (UNEXPECTED(!name)) {
27552
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27553
0
      UNDEF_RESULT();
27554
0
      goto exit_assign_obj;
27555
0
    }
27556
53
  }
27557
27558
53
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27559
53
    ZVAL_DEREF(value);
27560
53
  }
27561
27562
53
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27563
27564
53
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27565
53
    zend_tmp_string_release(tmp_name);
27566
53
  }
27567
27568
53
free_and_exit_assign_obj:
27569
53
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27570
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27571
0
  }
27572
53
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27573
53
exit_assign_obj:
27574
53
  if (garbage) {
27575
0
    GC_DTOR_NO_REF(garbage);
27576
0
  }
27577
53
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27578
53
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27579
  /* assign_obj has two opcodes! */
27580
53
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27581
53
}
27582
27583
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27584
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27585
0
{
27586
0
  USE_OPLINE
27587
0
  zval *object, *value, tmp;
27588
0
  zend_object *zobj;
27589
0
  zend_string *name, *tmp_name;
27590
0
  zend_refcounted *garbage = NULL;
27591
27592
0
  SAVE_OPLINE();
27593
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27594
0
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
27595
27596
0
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27597
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27598
0
      object = Z_REFVAL_P(object);
27599
0
      goto assign_object;
27600
0
    }
27601
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27602
0
    value = &EG(uninitialized_zval);
27603
0
    goto free_and_exit_assign_obj;
27604
0
  }
27605
27606
0
assign_object:
27607
0
  zobj = Z_OBJ_P(object);
27608
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27609
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27610
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
27611
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27612
0
      zval *property_val;
27613
0
      zend_property_info *prop_info;
27614
27615
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27616
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27617
27618
0
assign_obj_simple:
27619
0
        property_val = OBJ_PROP(zobj, prop_offset);
27620
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
27621
0
          if (prop_info != NULL) {
27622
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27623
0
            goto free_and_exit_assign_obj;
27624
0
          } else {
27625
0
fast_assign_obj:
27626
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
27627
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27628
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
27629
0
            }
27630
0
            goto exit_assign_obj;
27631
0
          }
27632
0
        }
27633
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27634
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27635
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27636
0
          zobj = zend_lazy_object_init(zobj);
27637
0
          if (!zobj) {
27638
0
            value = &EG(uninitialized_zval);
27639
0
            goto free_and_exit_assign_obj;
27640
0
          }
27641
0
        }
27642
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27643
0
          rebuild_object_properties_internal(zobj);
27644
0
        }
27645
0
        if (EXPECTED(zobj->properties != NULL)) {
27646
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27647
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27648
0
              GC_DELREF(zobj->properties);
27649
0
            }
27650
0
            zobj->properties = zend_array_dup(zobj->properties);
27651
0
          }
27652
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
27653
0
          if (property_val) {
27654
0
            goto fast_assign_obj;
27655
0
          }
27656
0
        }
27657
27658
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27659
0
          if (IS_CV == IS_CONST) {
27660
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27661
0
              Z_ADDREF_P(value);
27662
0
            }
27663
0
          } else if (IS_CV != IS_TMP_VAR) {
27664
0
            if (Z_ISREF_P(value)) {
27665
0
              if (IS_CV == IS_VAR) {
27666
0
                zend_reference *ref = Z_REF_P(value);
27667
0
                if (GC_DELREF(ref) == 0) {
27668
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27669
0
                  efree_size(ref, sizeof(zend_reference));
27670
0
                  value = &tmp;
27671
0
                } else {
27672
0
                  value = Z_REFVAL_P(value);
27673
0
                  Z_TRY_ADDREF_P(value);
27674
0
                }
27675
0
              } else {
27676
0
                value = Z_REFVAL_P(value);
27677
0
                Z_TRY_ADDREF_P(value);
27678
0
              }
27679
0
            } else if (IS_CV == IS_CV) {
27680
0
              Z_TRY_ADDREF_P(value);
27681
0
            }
27682
0
          }
27683
0
          zend_hash_add_new(zobj->properties, name, value);
27684
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27685
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
27686
0
          }
27687
0
          goto exit_assign_obj;
27688
0
        }
27689
0
      } else {
27690
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27691
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27692
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
27693
0
          prop_offset = prop_info->offset;
27694
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27695
0
            prop_info = NULL;
27696
0
          }
27697
0
          goto assign_obj_simple;
27698
0
        }
27699
        /* Fall through to write_property for hooks. */
27700
0
      }
27701
0
    }
27702
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27703
0
  } else {
27704
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27705
0
    if (UNEXPECTED(!name)) {
27706
27707
0
      UNDEF_RESULT();
27708
0
      goto exit_assign_obj;
27709
0
    }
27710
0
  }
27711
27712
0
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
27713
0
    ZVAL_DEREF(value);
27714
0
  }
27715
27716
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27717
27718
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27719
0
    zend_tmp_string_release(tmp_name);
27720
0
  }
27721
27722
0
free_and_exit_assign_obj:
27723
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27724
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27725
0
  }
27726
27727
0
exit_assign_obj:
27728
0
  if (garbage) {
27729
0
    GC_DTOR_NO_REF(garbage);
27730
0
  }
27731
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27732
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27733
  /* assign_obj has two opcodes! */
27734
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27735
0
}
27736
27737
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27738
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27739
49
{
27740
49
  USE_OPLINE
27741
49
  zval *object_ptr, *orig_object_ptr;
27742
49
  zval *value;
27743
49
  zval *variable_ptr;
27744
49
  zval *dim;
27745
49
  zend_refcounted *garbage = NULL;
27746
27747
49
  SAVE_OPLINE();
27748
49
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27749
27750
49
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27751
49
try_assign_dim_array:
27752
49
    SEPARATE_ARRAY(object_ptr);
27753
49
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27754
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
27755
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27756
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
27757
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27758
0
          GC_ADDREF(ht);
27759
0
        }
27760
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27761
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27762
0
          zend_array_destroy(ht);
27763
0
          goto assign_dim_error;
27764
0
        }
27765
0
      }
27766
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
27767
0
        ZVAL_DEREF(value);
27768
0
      }
27769
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27770
0
      if (UNEXPECTED(value == NULL)) {
27771
0
        zend_cannot_add_element();
27772
0
        goto assign_dim_error;
27773
0
      } else if (IS_CONST == IS_CV) {
27774
0
        if (Z_REFCOUNTED_P(value)) {
27775
0
          Z_ADDREF_P(value);
27776
0
        }
27777
0
      } else if (IS_CONST == IS_VAR) {
27778
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
27779
0
        if (Z_ISREF_P(free_op_data)) {
27780
0
          if (Z_REFCOUNTED_P(value)) {
27781
0
            Z_ADDREF_P(value);
27782
0
          }
27783
0
          zval_ptr_dtor_nogc(free_op_data);
27784
0
        }
27785
0
      } else if (IS_CONST == IS_CONST) {
27786
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27787
0
          Z_ADDREF_P(value);
27788
0
        }
27789
0
      }
27790
49
    } else {
27791
49
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27792
49
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27793
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27794
49
      } else {
27795
49
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27796
49
      }
27797
49
      if (UNEXPECTED(variable_ptr == NULL)) {
27798
3
        goto assign_dim_error;
27799
3
      }
27800
46
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
27801
46
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27802
46
    }
27803
46
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27804
38
      ZVAL_COPY(EX_VAR(opline->result.var), value);
27805
38
    }
27806
46
    if (garbage) {
27807
0
      GC_DTOR_NO_REF(garbage);
27808
0
    }
27809
46
  } else {
27810
38
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
27811
5
      object_ptr = Z_REFVAL_P(object_ptr);
27812
5
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27813
0
        goto try_assign_dim_array;
27814
0
      }
27815
5
    }
27816
38
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27817
0
      zend_object *obj = Z_OBJ_P(object_ptr);
27818
27819
0
      GC_ADDREF(obj);
27820
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27821
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27822
0
        dim = ZVAL_UNDEFINED_OP2();
27823
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27824
0
        dim++;
27825
0
      }
27826
27827
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
27828
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27829
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27830
0
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
27831
0
        ZVAL_DEREF(value);
27832
0
      }
27833
27834
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27835
27836
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27837
0
        zend_objects_store_del(obj);
27838
0
      }
27839
38
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27840
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27841
0
        zend_use_new_element_for_string();
27842
27843
0
        UNDEF_RESULT();
27844
0
      } else {
27845
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27846
0
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
27847
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27848
27849
0
      }
27850
38
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27851
38
      if (Z_ISREF_P(orig_object_ptr)
27852
38
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27853
38
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27854
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27855
27856
0
        UNDEF_RESULT();
27857
38
      } else {
27858
38
        HashTable *ht = zend_new_array(8);
27859
38
        uint8_t old_type = Z_TYPE_P(object_ptr);
27860
27861
38
        ZVAL_ARR(object_ptr, ht);
27862
38
        if (UNEXPECTED(old_type == IS_FALSE)) {
27863
0
          GC_ADDREF(ht);
27864
0
          zend_false_to_array_deprecated();
27865
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27866
0
            zend_array_destroy(ht);
27867
0
            goto assign_dim_error;
27868
0
          }
27869
0
        }
27870
38
        goto try_assign_dim_array;
27871
38
      }
27872
38
    } else {
27873
0
      zend_use_scalar_as_array();
27874
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27875
3
assign_dim_error:
27876
27877
3
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27878
3
        ZVAL_NULL(EX_VAR(opline->result.var));
27879
3
      }
27880
3
    }
27881
38
  }
27882
49
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27883
49
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27884
49
  }
27885
49
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27886
  /* assign_dim has two opcodes! */
27887
49
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27888
49
}
27889
27890
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27891
193
{
27892
193
  USE_OPLINE
27893
193
  zval *object_ptr, *orig_object_ptr;
27894
193
  zval *value;
27895
193
  zval *variable_ptr;
27896
193
  zval *dim;
27897
193
  zend_refcounted *garbage = NULL;
27898
27899
193
  SAVE_OPLINE();
27900
193
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27901
27902
193
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27903
193
try_assign_dim_array:
27904
193
    SEPARATE_ARRAY(object_ptr);
27905
193
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27906
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27907
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27908
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
27909
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27910
0
          GC_ADDREF(ht);
27911
0
        }
27912
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27913
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27914
0
          zend_array_destroy(ht);
27915
0
          goto assign_dim_error;
27916
0
        }
27917
0
      }
27918
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27919
0
        ZVAL_DEREF(value);
27920
0
      }
27921
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27922
0
      if (UNEXPECTED(value == NULL)) {
27923
0
        zend_cannot_add_element();
27924
0
        goto assign_dim_error;
27925
0
      } else if (IS_TMP_VAR == IS_CV) {
27926
0
        if (Z_REFCOUNTED_P(value)) {
27927
0
          Z_ADDREF_P(value);
27928
0
        }
27929
0
      } else if (IS_TMP_VAR == IS_VAR) {
27930
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
27931
0
        if (Z_ISREF_P(free_op_data)) {
27932
0
          if (Z_REFCOUNTED_P(value)) {
27933
0
            Z_ADDREF_P(value);
27934
0
          }
27935
0
          zval_ptr_dtor_nogc(free_op_data);
27936
0
        }
27937
0
      } else if (IS_TMP_VAR == IS_CONST) {
27938
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27939
0
          Z_ADDREF_P(value);
27940
0
        }
27941
0
      }
27942
193
    } else {
27943
193
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27944
193
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27945
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27946
193
      } else {
27947
193
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27948
193
      }
27949
193
      if (UNEXPECTED(variable_ptr == NULL)) {
27950
0
        goto assign_dim_error;
27951
0
      }
27952
193
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27953
193
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27954
193
    }
27955
193
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27956
141
      ZVAL_COPY(EX_VAR(opline->result.var), value);
27957
141
    }
27958
193
    if (garbage) {
27959
8
      GC_DTOR_NO_REF(garbage);
27960
8
    }
27961
193
  } else {
27962
31
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
27963
0
      object_ptr = Z_REFVAL_P(object_ptr);
27964
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27965
0
        goto try_assign_dim_array;
27966
0
      }
27967
0
    }
27968
31
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27969
0
      zend_object *obj = Z_OBJ_P(object_ptr);
27970
27971
0
      GC_ADDREF(obj);
27972
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27973
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27974
0
        dim = ZVAL_UNDEFINED_OP2();
27975
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27976
0
        dim++;
27977
0
      }
27978
27979
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27980
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27981
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27982
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
27983
0
        ZVAL_DEREF(value);
27984
0
      }
27985
27986
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27987
27988
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27989
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27990
0
        zend_objects_store_del(obj);
27991
0
      }
27992
31
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27993
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27994
0
        zend_use_new_element_for_string();
27995
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27996
0
        UNDEF_RESULT();
27997
0
      } else {
27998
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27999
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28000
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28001
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28002
0
      }
28003
31
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28004
31
      if (Z_ISREF_P(orig_object_ptr)
28005
31
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28006
31
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28007
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28008
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28009
0
        UNDEF_RESULT();
28010
31
      } else {
28011
31
        HashTable *ht = zend_new_array(8);
28012
31
        uint8_t old_type = Z_TYPE_P(object_ptr);
28013
28014
31
        ZVAL_ARR(object_ptr, ht);
28015
31
        if (UNEXPECTED(old_type == IS_FALSE)) {
28016
0
          GC_ADDREF(ht);
28017
0
          zend_false_to_array_deprecated();
28018
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28019
0
            zend_array_destroy(ht);
28020
0
            goto assign_dim_error;
28021
0
          }
28022
0
        }
28023
31
        goto try_assign_dim_array;
28024
31
      }
28025
31
    } else {
28026
0
      zend_use_scalar_as_array();
28027
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28028
0
assign_dim_error:
28029
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28030
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28031
0
        ZVAL_NULL(EX_VAR(opline->result.var));
28032
0
      }
28033
0
    }
28034
31
  }
28035
193
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28036
193
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28037
193
  }
28038
193
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28039
  /* assign_dim has two opcodes! */
28040
193
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28041
193
}
28042
28043
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28044
0
{
28045
0
  USE_OPLINE
28046
0
  zval *object_ptr, *orig_object_ptr;
28047
0
  zval *value;
28048
0
  zval *variable_ptr;
28049
0
  zval *dim;
28050
0
  zend_refcounted *garbage = NULL;
28051
28052
0
  SAVE_OPLINE();
28053
0
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28054
28055
0
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28056
0
try_assign_dim_array:
28057
0
    SEPARATE_ARRAY(object_ptr);
28058
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28059
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28060
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28061
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
28062
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28063
0
          GC_ADDREF(ht);
28064
0
        }
28065
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28066
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28067
0
          zend_array_destroy(ht);
28068
0
          goto assign_dim_error;
28069
0
        }
28070
0
      }
28071
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28072
0
        ZVAL_DEREF(value);
28073
0
      }
28074
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28075
0
      if (UNEXPECTED(value == NULL)) {
28076
0
        zend_cannot_add_element();
28077
0
        goto assign_dim_error;
28078
0
      } else if (IS_VAR == IS_CV) {
28079
0
        if (Z_REFCOUNTED_P(value)) {
28080
0
          Z_ADDREF_P(value);
28081
0
        }
28082
0
      } else if (IS_VAR == IS_VAR) {
28083
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
28084
0
        if (Z_ISREF_P(free_op_data)) {
28085
0
          if (Z_REFCOUNTED_P(value)) {
28086
0
            Z_ADDREF_P(value);
28087
0
          }
28088
0
          zval_ptr_dtor_nogc(free_op_data);
28089
0
        }
28090
0
      } else if (IS_VAR == IS_CONST) {
28091
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28092
0
          Z_ADDREF_P(value);
28093
0
        }
28094
0
      }
28095
0
    } else {
28096
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28097
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28098
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28099
0
      } else {
28100
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28101
0
      }
28102
0
      if (UNEXPECTED(variable_ptr == NULL)) {
28103
0
        goto assign_dim_error;
28104
0
      }
28105
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28106
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28107
0
    }
28108
0
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28109
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
28110
0
    }
28111
0
    if (garbage) {
28112
0
      GC_DTOR_NO_REF(garbage);
28113
0
    }
28114
0
  } else {
28115
0
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
28116
0
      object_ptr = Z_REFVAL_P(object_ptr);
28117
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28118
0
        goto try_assign_dim_array;
28119
0
      }
28120
0
    }
28121
0
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28122
0
      zend_object *obj = Z_OBJ_P(object_ptr);
28123
28124
0
      GC_ADDREF(obj);
28125
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28126
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28127
0
        dim = ZVAL_UNDEFINED_OP2();
28128
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28129
0
        dim++;
28130
0
      }
28131
28132
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28133
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28134
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28135
0
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
28136
0
        ZVAL_DEREF(value);
28137
0
      }
28138
28139
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28140
28141
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28142
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28143
0
        zend_objects_store_del(obj);
28144
0
      }
28145
0
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28146
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28147
0
        zend_use_new_element_for_string();
28148
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28149
0
        UNDEF_RESULT();
28150
0
      } else {
28151
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28152
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28153
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28154
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28155
0
      }
28156
0
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28157
0
      if (Z_ISREF_P(orig_object_ptr)
28158
0
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28159
0
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28160
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28161
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28162
0
        UNDEF_RESULT();
28163
0
      } else {
28164
0
        HashTable *ht = zend_new_array(8);
28165
0
        uint8_t old_type = Z_TYPE_P(object_ptr);
28166
28167
0
        ZVAL_ARR(object_ptr, ht);
28168
0
        if (UNEXPECTED(old_type == IS_FALSE)) {
28169
0
          GC_ADDREF(ht);
28170
0
          zend_false_to_array_deprecated();
28171
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28172
0
            zend_array_destroy(ht);
28173
0
            goto assign_dim_error;
28174
0
          }
28175
0
        }
28176
0
        goto try_assign_dim_array;
28177
0
      }
28178
0
    } else {
28179
0
      zend_use_scalar_as_array();
28180
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28181
0
assign_dim_error:
28182
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28183
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28184
0
        ZVAL_NULL(EX_VAR(opline->result.var));
28185
0
      }
28186
0
    }
28187
0
  }
28188
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28189
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28190
0
  }
28191
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28192
  /* assign_dim has two opcodes! */
28193
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28194
0
}
28195
28196
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28197
5
{
28198
5
  USE_OPLINE
28199
5
  zval *object_ptr, *orig_object_ptr;
28200
5
  zval *value;
28201
5
  zval *variable_ptr;
28202
5
  zval *dim;
28203
5
  zend_refcounted *garbage = NULL;
28204
28205
5
  SAVE_OPLINE();
28206
5
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28207
28208
5
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28209
0
try_assign_dim_array:
28210
0
    SEPARATE_ARRAY(object_ptr);
28211
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28212
0
      value = EX_VAR((opline+1)->op1.var);
28213
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28214
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
28215
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28216
0
          GC_ADDREF(ht);
28217
0
        }
28218
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28219
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28220
0
          zend_array_destroy(ht);
28221
0
          goto assign_dim_error;
28222
0
        }
28223
0
      }
28224
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
28225
0
        ZVAL_DEREF(value);
28226
0
      }
28227
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28228
0
      if (UNEXPECTED(value == NULL)) {
28229
0
        zend_cannot_add_element();
28230
0
        goto assign_dim_error;
28231
0
      } else if (IS_CV == IS_CV) {
28232
0
        if (Z_REFCOUNTED_P(value)) {
28233
0
          Z_ADDREF_P(value);
28234
0
        }
28235
0
      } else if (IS_CV == IS_VAR) {
28236
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
28237
0
        if (Z_ISREF_P(free_op_data)) {
28238
0
          if (Z_REFCOUNTED_P(value)) {
28239
0
            Z_ADDREF_P(value);
28240
0
          }
28241
0
          zval_ptr_dtor_nogc(free_op_data);
28242
0
        }
28243
0
      } else if (IS_CV == IS_CONST) {
28244
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28245
0
          Z_ADDREF_P(value);
28246
0
        }
28247
0
      }
28248
0
    } else {
28249
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28250
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28251
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28252
0
      } else {
28253
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28254
0
      }
28255
0
      if (UNEXPECTED(variable_ptr == NULL)) {
28256
0
        goto assign_dim_error;
28257
0
      }
28258
0
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
28259
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
28260
0
    }
28261
0
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28262
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
28263
0
    }
28264
0
    if (garbage) {
28265
0
      GC_DTOR_NO_REF(garbage);
28266
0
    }
28267
5
  } else {
28268
5
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
28269
0
      object_ptr = Z_REFVAL_P(object_ptr);
28270
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28271
0
        goto try_assign_dim_array;
28272
0
      }
28273
0
    }
28274
5
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28275
5
      zend_object *obj = Z_OBJ_P(object_ptr);
28276
28277
5
      GC_ADDREF(obj);
28278
5
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28279
5
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28280
0
        dim = ZVAL_UNDEFINED_OP2();
28281
5
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28282
0
        dim++;
28283
0
      }
28284
28285
5
      value = EX_VAR((opline+1)->op1.var);
28286
5
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28287
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28288
5
      } else if (IS_CV & (IS_CV|IS_VAR)) {
28289
5
        ZVAL_DEREF(value);
28290
5
      }
28291
28292
5
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28293
28294
5
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28295
0
        zend_objects_store_del(obj);
28296
0
      }
28297
5
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28298
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28299
0
        zend_use_new_element_for_string();
28300
28301
0
        UNDEF_RESULT();
28302
0
      } else {
28303
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28304
0
        value = EX_VAR((opline+1)->op1.var);
28305
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28306
28307
0
      }
28308
0
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28309
0
      if (Z_ISREF_P(orig_object_ptr)
28310
0
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28311
0
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28312
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28313
28314
0
        UNDEF_RESULT();
28315
0
      } else {
28316
0
        HashTable *ht = zend_new_array(8);
28317
0
        uint8_t old_type = Z_TYPE_P(object_ptr);
28318
28319
0
        ZVAL_ARR(object_ptr, ht);
28320
0
        if (UNEXPECTED(old_type == IS_FALSE)) {
28321
0
          GC_ADDREF(ht);
28322
0
          zend_false_to_array_deprecated();
28323
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28324
0
            zend_array_destroy(ht);
28325
0
            goto assign_dim_error;
28326
0
          }
28327
0
        }
28328
0
        goto try_assign_dim_array;
28329
0
      }
28330
0
    } else {
28331
0
      zend_use_scalar_as_array();
28332
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28333
0
assign_dim_error:
28334
28335
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28336
0
        ZVAL_NULL(EX_VAR(opline->result.var));
28337
0
      }
28338
0
    }
28339
5
  }
28340
5
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28341
5
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28342
5
  }
28343
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28344
  /* assign_dim has two opcodes! */
28345
5
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28346
5
}
28347
28348
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28349
0
{
28350
0
  USE_OPLINE
28351
0
  zval *property, *container, *value_ptr;
28352
28353
0
  SAVE_OPLINE();
28354
28355
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28356
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28357
28358
0
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28359
28360
0
  if (1) {
28361
0
    if (IS_VAR == IS_UNUSED) {
28362
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28363
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28364
0
      } else {
28365
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28366
0
      }
28367
0
    } else {
28368
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28369
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28370
0
      } else {
28371
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28372
0
      }
28373
0
    }
28374
0
  } else {
28375
0
    zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
28376
0
  }
28377
28378
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28379
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28380
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28381
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28382
0
}
28383
28384
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
28385
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28386
0
{
28387
0
  USE_OPLINE
28388
0
  zval *property, *container, *value_ptr;
28389
28390
0
  SAVE_OPLINE();
28391
28392
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28393
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28394
28395
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
28396
28397
0
  if (1) {
28398
0
    if (IS_VAR == IS_UNUSED) {
28399
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28400
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28401
0
      } else {
28402
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28403
0
      }
28404
0
    } else {
28405
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28406
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28407
0
      } else {
28408
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28409
0
      }
28410
0
    }
28411
0
  } else {
28412
0
    zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
28413
0
  }
28414
28415
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28416
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28417
28418
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28419
0
}
28420
28421
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
28422
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28423
5
{
28424
5
  USE_OPLINE
28425
5
  zval *function_name;
28426
5
  zend_class_entry *ce;
28427
5
  uint32_t call_info;
28428
5
  zend_function *fbc;
28429
5
  zend_execute_data *call;
28430
28431
5
  SAVE_OPLINE();
28432
28433
5
  if (IS_VAR == IS_CONST) {
28434
    /* no function found. try a static method in class */
28435
0
    ce = CACHED_PTR(opline->result.num);
28436
0
    if (UNEXPECTED(ce == NULL)) {
28437
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
28438
0
      if (UNEXPECTED(ce == NULL)) {
28439
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28440
0
        HANDLE_EXCEPTION();
28441
0
      }
28442
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28443
0
        CACHE_PTR(opline->result.num, ce);
28444
0
      }
28445
0
    }
28446
5
  } else if (IS_VAR == IS_UNUSED) {
28447
0
    ce = zend_fetch_class(NULL, opline->op1.num);
28448
0
    if (UNEXPECTED(ce == NULL)) {
28449
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28450
0
      HANDLE_EXCEPTION();
28451
0
    }
28452
5
  } else {
28453
5
    ce = Z_CE_P(EX_VAR(opline->op1.var));
28454
5
  }
28455
28456
5
  if (IS_VAR == IS_CONST &&
28457
5
      (IS_TMP_VAR|IS_VAR) == IS_CONST &&
28458
5
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
28459
    /* nothing to do */
28460
5
  } else if (IS_VAR != IS_CONST &&
28461
5
             (IS_TMP_VAR|IS_VAR) == IS_CONST &&
28462
5
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
28463
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
28464
5
  } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28465
5
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28466
5
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28467
5
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
28468
0
        do {
28469
0
          if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
28470
0
            function_name = Z_REFVAL_P(function_name);
28471
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
28472
0
              break;
28473
0
            }
28474
0
          } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
28475
0
            ZVAL_UNDEFINED_OP2();
28476
0
            if (UNEXPECTED(EG(exception) != NULL)) {
28477
0
              HANDLE_EXCEPTION();
28478
0
            }
28479
0
          }
28480
0
          zend_throw_error(NULL, "Method name must be a string");
28481
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28482
0
          HANDLE_EXCEPTION();
28483
0
        } while (0);
28484
0
      }
28485
5
    }
28486
28487
5
    if (ce->get_static_method) {
28488
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
28489
5
    } else {
28490
5
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
28491
5
    }
28492
5
    if (UNEXPECTED(fbc == NULL)) {
28493
0
      if (EXPECTED(!EG(exception))) {
28494
0
        zend_undefined_method(ce, Z_STR_P(function_name));
28495
0
      }
28496
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28497
0
      HANDLE_EXCEPTION();
28498
0
    }
28499
5
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
28500
5
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
28501
5
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
28502
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
28503
0
    }
28504
5
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
28505
0
      init_func_run_time_cache(&fbc->op_array);
28506
0
    }
28507
5
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28508
5
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28509
5
    }
28510
5
  } else {
28511
0
    if (UNEXPECTED(ce->constructor == NULL)) {
28512
0
      zend_throw_error(NULL, "Cannot call constructor");
28513
0
      HANDLE_EXCEPTION();
28514
0
    }
28515
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
28516
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
28517
0
      HANDLE_EXCEPTION();
28518
0
    }
28519
0
    fbc = ce->constructor;
28520
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
28521
0
      init_func_run_time_cache(&fbc->op_array);
28522
0
    }
28523
0
  }
28524
28525
5
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
28526
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
28527
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
28528
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
28529
0
    } else {
28530
0
      zend_non_static_method_call(fbc);
28531
0
      HANDLE_EXCEPTION();
28532
0
    }
28533
5
  } else {
28534
    /* previous opcode is ZEND_FETCH_CLASS */
28535
5
    if (IS_VAR == IS_UNUSED
28536
5
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
28537
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
28538
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
28539
0
        ce = Z_OBJCE(EX(This));
28540
0
      } else {
28541
0
        ce = Z_CE(EX(This));
28542
0
      }
28543
0
    }
28544
5
    call_info = ZEND_CALL_NESTED_FUNCTION;
28545
5
  }
28546
28547
5
  call = zend_vm_stack_push_call_frame(call_info,
28548
5
    fbc, opline->extended_value, ce);
28549
5
  call->prev_execute_data = EX(call);
28550
5
  EX(call) = call;
28551
28552
5
  ZEND_VM_NEXT_OPCODE();
28553
5
}
28554
28555
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28556
0
{
28557
0
  USE_OPLINE
28558
0
  zval *expr_ptr, new_expr;
28559
28560
0
  SAVE_OPLINE();
28561
0
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
28562
0
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
28563
0
    expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28564
0
    if (Z_ISREF_P(expr_ptr)) {
28565
0
      Z_ADDREF_P(expr_ptr);
28566
0
    } else {
28567
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
28568
0
    }
28569
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28570
0
  } else {
28571
0
    expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28572
0
    if (IS_VAR == IS_TMP_VAR) {
28573
      /* pass */
28574
0
    } else if (IS_VAR == IS_CONST) {
28575
0
      Z_TRY_ADDREF_P(expr_ptr);
28576
0
    } else if (IS_VAR == IS_CV) {
28577
0
      ZVAL_DEREF(expr_ptr);
28578
0
      Z_TRY_ADDREF_P(expr_ptr);
28579
0
    } else /* if (IS_VAR == IS_VAR) */ {
28580
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
28581
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
28582
28583
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
28584
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
28585
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
28586
0
          expr_ptr = &new_expr;
28587
0
          efree_size(ref, sizeof(zend_reference));
28588
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
28589
0
          Z_ADDREF_P(expr_ptr);
28590
0
        }
28591
0
      }
28592
0
    }
28593
0
  }
28594
28595
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28596
0
    zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28597
0
    zend_string *str;
28598
0
    zend_ulong hval;
28599
28600
0
add_again:
28601
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
28602
0
      str = Z_STR_P(offset);
28603
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28604
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
28605
0
          goto num_index;
28606
0
        }
28607
0
      }
28608
0
str_index:
28609
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
28610
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
28611
0
      hval = Z_LVAL_P(offset);
28612
0
num_index:
28613
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
28614
0
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
28615
0
      offset = Z_REFVAL_P(offset);
28616
0
      goto add_again;
28617
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
28618
0
      str = ZSTR_EMPTY_ALLOC();
28619
0
      goto str_index;
28620
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
28621
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
28622
0
      goto num_index;
28623
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
28624
0
      hval = 0;
28625
0
      goto num_index;
28626
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
28627
0
      hval = 1;
28628
0
      goto num_index;
28629
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
28630
0
      zend_use_resource_as_offset(offset);
28631
0
      hval = Z_RES_HANDLE_P(offset);
28632
0
      goto num_index;
28633
0
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
28634
0
      ZVAL_UNDEFINED_OP2();
28635
0
      str = ZSTR_EMPTY_ALLOC();
28636
0
      goto str_index;
28637
0
    } else {
28638
0
      zend_illegal_array_offset_access(offset);
28639
0
      zval_ptr_dtor_nogc(expr_ptr);
28640
0
    }
28641
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28642
0
  } else {
28643
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
28644
0
      zend_cannot_add_element();
28645
0
      zval_ptr_dtor_nogc(expr_ptr);
28646
0
    }
28647
0
  }
28648
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28649
0
}
28650
28651
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28652
0
{
28653
0
  zval *array;
28654
0
  uint32_t size;
28655
0
  USE_OPLINE
28656
28657
0
  SAVE_OPLINE();
28658
0
  array = EX_VAR(opline->result.var);
28659
0
  if (IS_VAR != IS_UNUSED) {
28660
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
28661
0
    ZVAL_ARR(array, zend_new_array(size));
28662
    /* Explicitly initialize array as not-packed if flag is set */
28663
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
28664
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
28665
0
    }
28666
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28667
0
  } else {
28668
0
    ZVAL_ARR(array, zend_new_array(0));
28669
0
    ZEND_VM_NEXT_OPCODE();
28670
0
  }
28671
0
}
28672
28673
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28674
50
{
28675
50
  USE_OPLINE
28676
50
  zval *container;
28677
50
  zval *offset;
28678
50
  zend_ulong hval;
28679
50
  zend_string *key;
28680
28681
50
  SAVE_OPLINE();
28682
50
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28683
50
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28684
28685
50
  do {
28686
50
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28687
38
      HashTable *ht;
28688
28689
38
unset_dim_array:
28690
38
      SEPARATE_ARRAY(container);
28691
38
      ht = Z_ARRVAL_P(container);
28692
38
offset_again:
28693
38
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
28694
0
        key = Z_STR_P(offset);
28695
0
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28696
0
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
28697
0
            goto num_index_dim;
28698
0
          }
28699
0
        }
28700
0
str_index_dim:
28701
0
        ZEND_ASSERT(ht != &EG(symbol_table));
28702
0
        zend_hash_del(ht, key);
28703
38
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
28704
38
        hval = Z_LVAL_P(offset);
28705
38
num_index_dim:
28706
38
        zend_hash_index_del(ht, hval);
28707
38
      } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
28708
0
        offset = Z_REFVAL_P(offset);
28709
0
        goto offset_again;
28710
0
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
28711
0
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
28712
0
        goto num_index_dim;
28713
0
      } else if (Z_TYPE_P(offset) == IS_NULL) {
28714
0
        key = ZSTR_EMPTY_ALLOC();
28715
0
        goto str_index_dim;
28716
0
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
28717
0
        hval = 0;
28718
0
        goto num_index_dim;
28719
0
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
28720
0
        hval = 1;
28721
0
        goto num_index_dim;
28722
0
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
28723
0
        zend_use_resource_as_offset(offset);
28724
0
        hval = Z_RES_HANDLE_P(offset);
28725
0
        goto num_index_dim;
28726
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
28727
0
        ZVAL_UNDEFINED_OP2();
28728
0
        key = ZSTR_EMPTY_ALLOC();
28729
0
        goto str_index_dim;
28730
0
      } else {
28731
0
        zend_illegal_array_offset_unset(offset);
28732
0
      }
28733
38
      break;
28734
38
    } else if (Z_ISREF_P(container)) {
28735
0
      container = Z_REFVAL_P(container);
28736
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28737
0
        goto unset_dim_array;
28738
0
      }
28739
0
    }
28740
12
    if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
28741
0
      container = ZVAL_UNDEFINED_OP1();
28742
0
    }
28743
12
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
28744
0
      offset = ZVAL_UNDEFINED_OP2();
28745
0
    }
28746
12
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
28747
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
28748
0
        offset++;
28749
0
      }
28750
0
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
28751
12
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
28752
0
      zend_throw_error(NULL, "Cannot unset string offsets");
28753
12
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
28754
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
28755
12
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
28756
0
      zend_false_to_array_deprecated();
28757
0
    }
28758
12
  } while (0);
28759
28760
50
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28761
50
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28762
50
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28763
50
}
28764
28765
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28766
0
{
28767
0
  USE_OPLINE
28768
0
  zval *container;
28769
0
  zval *offset;
28770
0
  zend_string *name, *tmp_name;
28771
28772
0
  SAVE_OPLINE();
28773
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28774
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28775
28776
0
  do {
28777
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
28778
0
      if (Z_ISREF_P(container)) {
28779
0
        container = Z_REFVAL_P(container);
28780
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
28781
0
          if (IS_VAR == IS_CV
28782
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
28783
0
            ZVAL_UNDEFINED_OP1();
28784
0
          }
28785
0
          break;
28786
0
        }
28787
0
      } else {
28788
0
        break;
28789
0
      }
28790
0
    }
28791
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28792
0
      name = Z_STR_P(offset);
28793
0
    } else {
28794
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
28795
0
      if (UNEXPECTED(!name)) {
28796
0
        break;
28797
0
      }
28798
0
    }
28799
0
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
28800
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28801
0
      zend_tmp_string_release(tmp_name);
28802
0
    }
28803
0
  } while (0);
28804
28805
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28806
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28807
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28808
0
}
28809
28810
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28811
0
{
28812
0
  USE_OPLINE
28813
28814
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
28815
28816
0
  SAVE_OPLINE();
28817
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
28818
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28819
0
  }
28820
28821
  /* Destroy the previously yielded value */
28822
0
  zval_ptr_dtor(&generator->value);
28823
28824
  /* Destroy the previously yielded key */
28825
0
  zval_ptr_dtor(&generator->key);
28826
28827
  /* Set the new yielded value */
28828
0
  if (IS_VAR != IS_UNUSED) {
28829
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
28830
      /* Constants and temporary variables aren't yieldable by reference,
28831
       * but we still allow them with a notice. */
28832
0
      if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
28833
0
        zval *value;
28834
28835
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28836
28837
0
        value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28838
0
        ZVAL_COPY_VALUE(&generator->value, value);
28839
0
        if (IS_VAR == IS_CONST) {
28840
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28841
0
            Z_ADDREF(generator->value);
28842
0
          }
28843
0
        }
28844
0
      } else {
28845
0
        zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28846
28847
        /* If a function call result is yielded and the function did
28848
         * not return by reference we throw a notice. */
28849
0
        do {
28850
0
          if (IS_VAR == IS_VAR) {
28851
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
28852
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
28853
0
             && !Z_ISREF_P(value_ptr)) {
28854
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28855
0
              ZVAL_COPY(&generator->value, value_ptr);
28856
0
              break;
28857
0
            }
28858
0
          }
28859
0
          if (Z_ISREF_P(value_ptr)) {
28860
0
            Z_ADDREF_P(value_ptr);
28861
0
          } else {
28862
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
28863
0
          }
28864
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
28865
0
        } while (0);
28866
28867
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28868
0
      }
28869
0
    } else {
28870
0
      zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28871
28872
      /* Consts, temporary variables and references need copying */
28873
0
      if (IS_VAR == IS_CONST) {
28874
0
        ZVAL_COPY_VALUE(&generator->value, value);
28875
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28876
0
          Z_ADDREF(generator->value);
28877
0
        }
28878
0
      } else if (IS_VAR == IS_TMP_VAR) {
28879
0
        ZVAL_COPY_VALUE(&generator->value, value);
28880
0
      } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
28881
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
28882
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28883
0
      } else {
28884
0
        ZVAL_COPY_VALUE(&generator->value, value);
28885
0
        if (IS_VAR == IS_CV) {
28886
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
28887
0
        }
28888
0
      }
28889
0
    }
28890
0
  } else {
28891
    /* If no value was specified yield null */
28892
0
    ZVAL_NULL(&generator->value);
28893
0
  }
28894
28895
  /* Set the new yielded key */
28896
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28897
0
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28898
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
28899
0
      key = Z_REFVAL_P(key);
28900
0
    }
28901
0
    ZVAL_COPY(&generator->key, key);
28902
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28903
28904
0
    if (Z_TYPE(generator->key) == IS_LONG
28905
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
28906
0
    ) {
28907
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
28908
0
    }
28909
0
  } else {
28910
    /* If no key was specified we use auto-increment keys */
28911
0
    generator->largest_used_integer_key++;
28912
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
28913
0
  }
28914
28915
0
  if (RETURN_VALUE_USED(opline)) {
28916
    /* If the return value of yield is used set the send
28917
     * target and initialize it to NULL */
28918
0
    generator->send_target = EX_VAR(opline->result.var);
28919
0
    ZVAL_NULL(generator->send_target);
28920
0
  } else {
28921
0
    generator->send_target = NULL;
28922
0
  }
28923
28924
  /* The GOTO VM uses a local opline variable. We need to set the opline
28925
   * variable in execute_data so we don't resume at an old position. */
28926
0
  SAVE_OPLINE();
28927
28928
0
  ZEND_VM_RETURN();
28929
0
}
28930
28931
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28932
36
{
28933
36
  USE_OPLINE
28934
36
  zval *op1, *op2;
28935
36
  bool result;
28936
28937
36
  SAVE_OPLINE();
28938
36
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28939
36
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28940
36
  result = fast_is_identical_function(op1, op2);
28941
36
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28942
36
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28943
36
  ZEND_VM_SMART_BRANCH(result, 1);
28944
36
}
28945
28946
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28947
0
{
28948
0
  USE_OPLINE
28949
0
  zval *op1, *op2;
28950
0
  bool result;
28951
28952
0
  SAVE_OPLINE();
28953
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28954
0
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28955
0
  result = fast_is_identical_function(op1, op2);
28956
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28957
0
  ZEND_VM_SMART_BRANCH(result, 1);
28958
0
}
28959
28960
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28961
0
{
28962
0
  USE_OPLINE
28963
0
  zval *op1, *op2;
28964
0
  bool result;
28965
28966
0
  SAVE_OPLINE();
28967
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28968
0
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28969
0
  result = fast_is_not_identical_function(op1, op2);
28970
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28971
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28972
0
  ZEND_VM_SMART_BRANCH(result, 1);
28973
0
}
28974
28975
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28976
1.25k
{
28977
1.25k
  USE_OPLINE
28978
1.25k
  zval *value;
28979
1.25k
  zval *variable_ptr;
28980
28981
1.25k
  SAVE_OPLINE();
28982
1.25k
  value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28983
1.25k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28984
28985
1.25k
  if (0 || UNEXPECTED(0)) {
28986
0
    zend_refcounted *garbage = NULL;
28987
28988
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28989
0
    if (UNEXPECTED(0)) {
28990
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
28991
0
    }
28992
0
    if (garbage) {
28993
0
      GC_DTOR_NO_REF(garbage);
28994
0
    }
28995
1.25k
  } else {
28996
1.25k
    value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28997
1.25k
  }
28998
1.25k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28999
  /* zend_assign_to_variable() always takes care of op2, never free it! */
29000
29001
1.25k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29002
1.25k
}
29003
29004
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29005
4.93k
{
29006
4.93k
  USE_OPLINE
29007
4.93k
  zval *value;
29008
4.93k
  zval *variable_ptr;
29009
29010
4.93k
  SAVE_OPLINE();
29011
4.93k
  value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
29012
4.93k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29013
29014
4.93k
  if (0 || UNEXPECTED(1)) {
29015
4.93k
    zend_refcounted *garbage = NULL;
29016
29017
4.93k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
29018
4.93k
    if (UNEXPECTED(1)) {
29019
4.93k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29020
4.93k
    }
29021
4.93k
    if (garbage) {
29022
129
      GC_DTOR_NO_REF(garbage);
29023
129
    }
29024
4.93k
  } else {
29025
0
    value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
29026
0
  }
29027
4.93k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29028
  /* zend_assign_to_variable() always takes care of op2, never free it! */
29029
29030
4.93k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29031
4.93k
}
29032
29033
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29034
30
{
29035
30
  USE_OPLINE
29036
30
  zval *op1, *op2;
29037
30
  bool result;
29038
29039
30
  SAVE_OPLINE();
29040
30
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
29041
30
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
29042
30
  result = fast_is_identical_function(op1, op2);
29043
30
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29044
30
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29045
30
  ZEND_VM_SMART_BRANCH(result, 1);
29046
30
}
29047
29048
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29049
0
{
29050
0
  USE_OPLINE
29051
0
  zval *op1, *op2;
29052
0
  bool result;
29053
29054
0
  SAVE_OPLINE();
29055
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
29056
0
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
29057
0
  result = fast_is_identical_function(op1, op2);
29058
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29059
0
  ZEND_VM_SMART_BRANCH(result, 1);
29060
0
}
29061
29062
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29063
0
{
29064
0
  USE_OPLINE
29065
0
  zval *op1, *op2;
29066
0
  bool result;
29067
29068
0
  SAVE_OPLINE();
29069
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
29070
0
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
29071
0
  result = fast_is_not_identical_function(op1, op2);
29072
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29073
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29074
0
  ZEND_VM_SMART_BRANCH(result, 1);
29075
0
}
29076
29077
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29078
8.01k
{
29079
8.01k
  USE_OPLINE
29080
8.01k
  zval *value;
29081
8.01k
  zval *variable_ptr;
29082
29083
8.01k
  SAVE_OPLINE();
29084
8.01k
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
29085
8.01k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29086
29087
8.01k
  if (0 || UNEXPECTED(0)) {
29088
0
    zend_refcounted *garbage = NULL;
29089
29090
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29091
0
    if (UNEXPECTED(0)) {
29092
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29093
0
    }
29094
0
    if (garbage) {
29095
0
      GC_DTOR_NO_REF(garbage);
29096
0
    }
29097
8.01k
  } else {
29098
8.01k
    value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
29099
8.01k
  }
29100
8.01k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29101
  /* zend_assign_to_variable() always takes care of op2, never free it! */
29102
29103
8.01k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29104
8.01k
}
29105
29106
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29107
0
{
29108
0
  USE_OPLINE
29109
0
  zval *value;
29110
0
  zval *variable_ptr;
29111
29112
0
  SAVE_OPLINE();
29113
0
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
29114
0
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29115
29116
0
  if (0 || UNEXPECTED(1)) {
29117
0
    zend_refcounted *garbage = NULL;
29118
29119
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29120
0
    if (UNEXPECTED(1)) {
29121
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29122
0
    }
29123
0
    if (garbage) {
29124
0
      GC_DTOR_NO_REF(garbage);
29125
0
    }
29126
0
  } else {
29127
0
    value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
29128
0
  }
29129
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29130
  /* zend_assign_to_variable() always takes care of op2, never free it! */
29131
29132
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29133
0
}
29134
29135
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29136
1.16k
{
29137
1.16k
  USE_OPLINE
29138
1.16k
  zval *variable_ptr;
29139
1.16k
  zval *value_ptr;
29140
1.16k
  zend_refcounted *garbage = NULL;
29141
29142
1.16k
  SAVE_OPLINE();
29143
1.16k
  value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
29144
1.16k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29145
29146
1.16k
  if (IS_VAR == IS_VAR &&
29147
1.16k
             UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
29148
29149
0
    zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
29150
0
    variable_ptr = &EG(uninitialized_zval);
29151
1.16k
  } else if (IS_VAR == IS_VAR &&
29152
1.16k
             opline->extended_value == ZEND_RETURNS_FUNCTION &&
29153
1.16k
         UNEXPECTED(!Z_ISREF_P(value_ptr))) {
29154
29155
5
    variable_ptr = zend_wrong_assign_to_variable_reference(
29156
5
      variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
29157
1.16k
  } else {
29158
1.16k
    zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
29159
1.16k
  }
29160
29161
1.16k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29162
109
    ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
29163
109
  }
29164
29165
1.16k
  if (garbage) {
29166
64
    GC_DTOR(garbage);
29167
64
  }
29168
29169
1.16k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29170
1.16k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29171
1.16k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29172
1.16k
}
29173
29174
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29175
5
{
29176
5
  USE_OPLINE
29177
5
  zval *var_ptr;
29178
5
  zval *value, *container, *dim;
29179
5
  HashTable *ht;
29180
29181
5
  SAVE_OPLINE();
29182
5
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29183
29184
5
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
29185
0
assign_dim_op_array:
29186
0
    SEPARATE_ARRAY(container);
29187
0
    ht = Z_ARRVAL_P(container);
29188
5
assign_dim_op_new_array:
29189
5
    dim = NULL;
29190
5
    if (IS_UNUSED == IS_UNUSED) {
29191
5
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
29192
5
      if (UNEXPECTED(!var_ptr)) {
29193
0
        zend_cannot_add_element();
29194
0
        goto assign_dim_op_ret_null;
29195
0
      }
29196
5
    } else {
29197
0
      if (IS_UNUSED == IS_CONST) {
29198
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
29199
0
      } else {
29200
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
29201
0
      }
29202
0
      if (UNEXPECTED(!var_ptr)) {
29203
0
        goto assign_dim_op_ret_null;
29204
0
      }
29205
0
    }
29206
29207
5
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
29208
29209
5
    do {
29210
5
      if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
29211
0
        zend_reference *ref = Z_REF_P(var_ptr);
29212
0
        var_ptr = Z_REFVAL_P(var_ptr);
29213
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
29214
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
29215
0
          break;
29216
0
        }
29217
0
      }
29218
5
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
29219
5
    } while (0);
29220
29221
5
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29222
0
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
29223
0
    }
29224
5
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
29225
5
  } else {
29226
5
    if (EXPECTED(Z_ISREF_P(container))) {
29227
0
      container = Z_REFVAL_P(container);
29228
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
29229
0
        goto assign_dim_op_array;
29230
0
      }
29231
0
    }
29232
29233
5
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
29234
0
      zend_object *obj = Z_OBJ_P(container);
29235
29236
0
      dim = NULL;
29237
0
      if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29238
0
        dim++;
29239
0
      }
29240
0
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
29241
5
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
29242
5
      uint8_t old_type;
29243
29244
5
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
29245
0
        ZVAL_UNDEFINED_OP1();
29246
0
      }
29247
5
      ht = zend_new_array(8);
29248
5
      old_type = Z_TYPE_P(container);
29249
5
      ZVAL_ARR(container, ht);
29250
5
      if (UNEXPECTED(old_type == IS_FALSE)) {
29251
0
        GC_ADDREF(ht);
29252
0
        zend_false_to_array_deprecated();
29253
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29254
0
          zend_array_destroy(ht);
29255
0
          goto assign_dim_op_ret_null;
29256
0
        }
29257
0
      }
29258
5
      goto assign_dim_op_new_array;
29259
5
    } else {
29260
0
      dim = NULL;
29261
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
29262
0
assign_dim_op_ret_null:
29263
0
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
29264
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29265
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29266
0
      }
29267
0
    }
29268
5
  }
29269
29270
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29271
5
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29272
5
}
29273
29274
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29275
79
{
29276
79
  USE_OPLINE
29277
79
  zval *container;
29278
29279
79
  SAVE_OPLINE();
29280
79
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29281
79
  zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
29282
29283
79
  if (IS_VAR == IS_VAR) {
29284
79
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
29285
79
  }
29286
79
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29287
79
}
29288
29289
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29290
5
{
29291
5
  USE_OPLINE
29292
5
  zval *container;
29293
29294
5
  SAVE_OPLINE();
29295
5
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29296
5
  zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
29297
29298
5
  if (IS_VAR == IS_VAR) {
29299
5
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
29300
5
  }
29301
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29302
5
}
29303
29304
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29305
0
{
29306
#if 0
29307
  USE_OPLINE
29308
#endif
29309
29310
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
29311
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
29312
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29313
0
    }
29314
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29315
0
  } else {
29316
0
    if (IS_UNUSED == IS_UNUSED) {
29317
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29318
0
    }
29319
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29320
0
  }
29321
0
}
29322
29323
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29324
1.21k
{
29325
1.21k
  USE_OPLINE
29326
1.21k
  zval *object_ptr, *orig_object_ptr;
29327
1.21k
  zval *value;
29328
1.21k
  zval *variable_ptr;
29329
1.21k
  zval *dim;
29330
1.21k
  zend_refcounted *garbage = NULL;
29331
29332
1.21k
  SAVE_OPLINE();
29333
1.21k
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29334
29335
1.21k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29336
1.20k
try_assign_dim_array:
29337
1.20k
    SEPARATE_ARRAY(object_ptr);
29338
1.20k
    if (IS_UNUSED == IS_UNUSED) {
29339
1.20k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
29340
1.20k
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29341
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
29342
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29343
0
          GC_ADDREF(ht);
29344
0
        }
29345
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29346
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29347
0
          zend_array_destroy(ht);
29348
0
          goto assign_dim_error;
29349
0
        }
29350
0
      }
29351
1.20k
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
29352
0
        ZVAL_DEREF(value);
29353
0
      }
29354
1.20k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29355
1.20k
      if (UNEXPECTED(value == NULL)) {
29356
5
        zend_cannot_add_element();
29357
5
        goto assign_dim_error;
29358
1.20k
      } else if (IS_CONST == IS_CV) {
29359
0
        if (Z_REFCOUNTED_P(value)) {
29360
0
          Z_ADDREF_P(value);
29361
0
        }
29362
1.20k
      } else if (IS_CONST == IS_VAR) {
29363
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
29364
0
        if (Z_ISREF_P(free_op_data)) {
29365
0
          if (Z_REFCOUNTED_P(value)) {
29366
0
            Z_ADDREF_P(value);
29367
0
          }
29368
0
          zval_ptr_dtor_nogc(free_op_data);
29369
0
        }
29370
1.20k
      } else if (IS_CONST == IS_CONST) {
29371
1.20k
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29372
0
          Z_ADDREF_P(value);
29373
0
        }
29374
1.20k
      }
29375
1.20k
    } else {
29376
0
      dim = NULL;
29377
0
      if (IS_UNUSED == IS_CONST) {
29378
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29379
0
      } else {
29380
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29381
0
      }
29382
0
      if (UNEXPECTED(variable_ptr == NULL)) {
29383
0
        goto assign_dim_error;
29384
0
      }
29385
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
29386
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
29387
0
    }
29388
1.20k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29389
35
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29390
35
    }
29391
1.20k
    if (garbage) {
29392
0
      GC_DTOR_NO_REF(garbage);
29393
0
    }
29394
1.20k
  } else {
29395
292
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
29396
24
      object_ptr = Z_REFVAL_P(object_ptr);
29397
24
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29398
24
        goto try_assign_dim_array;
29399
24
      }
29400
24
    }
29401
268
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29402
10
      zend_object *obj = Z_OBJ_P(object_ptr);
29403
29404
10
      GC_ADDREF(obj);
29405
10
      dim = NULL;
29406
10
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29407
0
        dim = ZVAL_UNDEFINED_OP2();
29408
10
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29409
0
        dim++;
29410
0
      }
29411
29412
10
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
29413
10
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29414
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29415
10
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
29416
0
        ZVAL_DEREF(value);
29417
0
      }
29418
29419
10
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29420
29421
10
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29422
0
        zend_objects_store_del(obj);
29423
0
      }
29424
258
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29425
0
      if (IS_UNUSED == IS_UNUSED) {
29426
0
        zend_use_new_element_for_string();
29427
29428
0
        UNDEF_RESULT();
29429
0
      } else {
29430
0
        dim = NULL;
29431
0
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
29432
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29433
29434
0
      }
29435
258
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29436
258
      if (Z_ISREF_P(orig_object_ptr)
29437
258
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29438
258
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29439
0
        dim = NULL;
29440
29441
0
        UNDEF_RESULT();
29442
258
      } else {
29443
258
        HashTable *ht = zend_new_array(8);
29444
258
        uint8_t old_type = Z_TYPE_P(object_ptr);
29445
29446
258
        ZVAL_ARR(object_ptr, ht);
29447
258
        if (UNEXPECTED(old_type == IS_FALSE)) {
29448
129
          GC_ADDREF(ht);
29449
129
          zend_false_to_array_deprecated();
29450
129
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29451
0
            zend_array_destroy(ht);
29452
0
            goto assign_dim_error;
29453
0
          }
29454
129
        }
29455
258
        goto try_assign_dim_array;
29456
258
      }
29457
258
    } else {
29458
0
      zend_use_scalar_as_array();
29459
0
      dim = NULL;
29460
5
assign_dim_error:
29461
29462
5
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29463
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29464
0
      }
29465
5
    }
29466
268
  }
29467
1.21k
  if (IS_UNUSED != IS_UNUSED) {
29468
29469
0
  }
29470
1.21k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29471
  /* assign_dim has two opcodes! */
29472
1.21k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29473
1.21k
}
29474
29475
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29476
1.02k
{
29477
1.02k
  USE_OPLINE
29478
1.02k
  zval *object_ptr, *orig_object_ptr;
29479
1.02k
  zval *value;
29480
1.02k
  zval *variable_ptr;
29481
1.02k
  zval *dim;
29482
1.02k
  zend_refcounted *garbage = NULL;
29483
29484
1.02k
  SAVE_OPLINE();
29485
1.02k
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29486
29487
1.02k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29488
1.02k
try_assign_dim_array:
29489
1.02k
    SEPARATE_ARRAY(object_ptr);
29490
1.02k
    if (IS_UNUSED == IS_UNUSED) {
29491
1.02k
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29492
1.02k
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29493
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
29494
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29495
0
          GC_ADDREF(ht);
29496
0
        }
29497
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29498
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29499
0
          zend_array_destroy(ht);
29500
0
          goto assign_dim_error;
29501
0
        }
29502
0
      }
29503
1.02k
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
29504
0
        ZVAL_DEREF(value);
29505
0
      }
29506
1.02k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29507
1.02k
      if (UNEXPECTED(value == NULL)) {
29508
0
        zend_cannot_add_element();
29509
0
        goto assign_dim_error;
29510
1.02k
      } else if (IS_TMP_VAR == IS_CV) {
29511
0
        if (Z_REFCOUNTED_P(value)) {
29512
0
          Z_ADDREF_P(value);
29513
0
        }
29514
1.02k
      } else if (IS_TMP_VAR == IS_VAR) {
29515
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
29516
0
        if (Z_ISREF_P(free_op_data)) {
29517
0
          if (Z_REFCOUNTED_P(value)) {
29518
0
            Z_ADDREF_P(value);
29519
0
          }
29520
0
          zval_ptr_dtor_nogc(free_op_data);
29521
0
        }
29522
1.02k
      } else if (IS_TMP_VAR == IS_CONST) {
29523
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29524
0
          Z_ADDREF_P(value);
29525
0
        }
29526
0
      }
29527
1.02k
    } else {
29528
0
      dim = NULL;
29529
0
      if (IS_UNUSED == IS_CONST) {
29530
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29531
0
      } else {
29532
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29533
0
      }
29534
0
      if (UNEXPECTED(variable_ptr == NULL)) {
29535
0
        goto assign_dim_error;
29536
0
      }
29537
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29538
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
29539
0
    }
29540
1.02k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29541
7
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29542
7
    }
29543
1.02k
    if (garbage) {
29544
0
      GC_DTOR_NO_REF(garbage);
29545
0
    }
29546
1.02k
  } else {
29547
114
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
29548
7
      object_ptr = Z_REFVAL_P(object_ptr);
29549
7
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29550
7
        goto try_assign_dim_array;
29551
7
      }
29552
7
    }
29553
107
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29554
0
      zend_object *obj = Z_OBJ_P(object_ptr);
29555
29556
0
      GC_ADDREF(obj);
29557
0
      dim = NULL;
29558
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29559
0
        dim = ZVAL_UNDEFINED_OP2();
29560
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29561
0
        dim++;
29562
0
      }
29563
29564
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29565
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29566
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29567
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
29568
0
        ZVAL_DEREF(value);
29569
0
      }
29570
29571
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29572
29573
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29574
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29575
0
        zend_objects_store_del(obj);
29576
0
      }
29577
107
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29578
0
      if (IS_UNUSED == IS_UNUSED) {
29579
0
        zend_use_new_element_for_string();
29580
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29581
0
        UNDEF_RESULT();
29582
0
      } else {
29583
0
        dim = NULL;
29584
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29585
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29586
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29587
0
      }
29588
107
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29589
107
      if (Z_ISREF_P(orig_object_ptr)
29590
107
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29591
107
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29592
0
        dim = NULL;
29593
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29594
0
        UNDEF_RESULT();
29595
107
      } else {
29596
107
        HashTable *ht = zend_new_array(8);
29597
107
        uint8_t old_type = Z_TYPE_P(object_ptr);
29598
29599
107
        ZVAL_ARR(object_ptr, ht);
29600
107
        if (UNEXPECTED(old_type == IS_FALSE)) {
29601
0
          GC_ADDREF(ht);
29602
0
          zend_false_to_array_deprecated();
29603
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29604
0
            zend_array_destroy(ht);
29605
0
            goto assign_dim_error;
29606
0
          }
29607
0
        }
29608
107
        goto try_assign_dim_array;
29609
107
      }
29610
107
    } else {
29611
0
      zend_use_scalar_as_array();
29612
0
      dim = NULL;
29613
0
assign_dim_error:
29614
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29615
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29616
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29617
0
      }
29618
0
    }
29619
107
  }
29620
1.02k
  if (IS_UNUSED != IS_UNUSED) {
29621
29622
0
  }
29623
1.02k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29624
  /* assign_dim has two opcodes! */
29625
1.02k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29626
1.02k
}
29627
29628
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29629
505
{
29630
505
  USE_OPLINE
29631
505
  zval *object_ptr, *orig_object_ptr;
29632
505
  zval *value;
29633
505
  zval *variable_ptr;
29634
505
  zval *dim;
29635
505
  zend_refcounted *garbage = NULL;
29636
29637
505
  SAVE_OPLINE();
29638
505
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29639
29640
505
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29641
505
try_assign_dim_array:
29642
505
    SEPARATE_ARRAY(object_ptr);
29643
505
    if (IS_UNUSED == IS_UNUSED) {
29644
505
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29645
505
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29646
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
29647
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29648
0
          GC_ADDREF(ht);
29649
0
        }
29650
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29651
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29652
0
          zend_array_destroy(ht);
29653
0
          goto assign_dim_error;
29654
0
        }
29655
0
      }
29656
505
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
29657
505
        ZVAL_DEREF(value);
29658
505
      }
29659
505
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29660
505
      if (UNEXPECTED(value == NULL)) {
29661
0
        zend_cannot_add_element();
29662
0
        goto assign_dim_error;
29663
505
      } else if (IS_VAR == IS_CV) {
29664
0
        if (Z_REFCOUNTED_P(value)) {
29665
0
          Z_ADDREF_P(value);
29666
0
        }
29667
505
      } else if (IS_VAR == IS_VAR) {
29668
505
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
29669
505
        if (Z_ISREF_P(free_op_data)) {
29670
0
          if (Z_REFCOUNTED_P(value)) {
29671
0
            Z_ADDREF_P(value);
29672
0
          }
29673
0
          zval_ptr_dtor_nogc(free_op_data);
29674
0
        }
29675
505
      } else if (IS_VAR == IS_CONST) {
29676
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29677
0
          Z_ADDREF_P(value);
29678
0
        }
29679
0
      }
29680
505
    } else {
29681
0
      dim = NULL;
29682
0
      if (IS_UNUSED == IS_CONST) {
29683
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29684
0
      } else {
29685
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29686
0
      }
29687
0
      if (UNEXPECTED(variable_ptr == NULL)) {
29688
0
        goto assign_dim_error;
29689
0
      }
29690
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29691
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29692
0
    }
29693
505
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29694
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29695
0
    }
29696
505
    if (garbage) {
29697
0
      GC_DTOR_NO_REF(garbage);
29698
0
    }
29699
505
  } else {
29700
14
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
29701
0
      object_ptr = Z_REFVAL_P(object_ptr);
29702
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29703
0
        goto try_assign_dim_array;
29704
0
      }
29705
0
    }
29706
14
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29707
0
      zend_object *obj = Z_OBJ_P(object_ptr);
29708
29709
0
      GC_ADDREF(obj);
29710
0
      dim = NULL;
29711
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29712
0
        dim = ZVAL_UNDEFINED_OP2();
29713
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29714
0
        dim++;
29715
0
      }
29716
29717
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29718
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29719
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29720
0
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
29721
0
        ZVAL_DEREF(value);
29722
0
      }
29723
29724
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29725
29726
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29727
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29728
0
        zend_objects_store_del(obj);
29729
0
      }
29730
14
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29731
0
      if (IS_UNUSED == IS_UNUSED) {
29732
0
        zend_use_new_element_for_string();
29733
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29734
0
        UNDEF_RESULT();
29735
0
      } else {
29736
0
        dim = NULL;
29737
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29738
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29739
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29740
0
      }
29741
14
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29742
14
      if (Z_ISREF_P(orig_object_ptr)
29743
14
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29744
14
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29745
0
        dim = NULL;
29746
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29747
0
        UNDEF_RESULT();
29748
14
      } else {
29749
14
        HashTable *ht = zend_new_array(8);
29750
14
        uint8_t old_type = Z_TYPE_P(object_ptr);
29751
29752
14
        ZVAL_ARR(object_ptr, ht);
29753
14
        if (UNEXPECTED(old_type == IS_FALSE)) {
29754
0
          GC_ADDREF(ht);
29755
0
          zend_false_to_array_deprecated();
29756
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29757
0
            zend_array_destroy(ht);
29758
0
            goto assign_dim_error;
29759
0
          }
29760
0
        }
29761
14
        goto try_assign_dim_array;
29762
14
      }
29763
14
    } else {
29764
0
      zend_use_scalar_as_array();
29765
0
      dim = NULL;
29766
0
assign_dim_error:
29767
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29768
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29769
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29770
0
      }
29771
0
    }
29772
14
  }
29773
505
  if (IS_UNUSED != IS_UNUSED) {
29774
29775
0
  }
29776
505
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29777
  /* assign_dim has two opcodes! */
29778
505
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29779
505
}
29780
29781
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29782
469
{
29783
469
  USE_OPLINE
29784
469
  zval *object_ptr, *orig_object_ptr;
29785
469
  zval *value;
29786
469
  zval *variable_ptr;
29787
469
  zval *dim;
29788
469
  zend_refcounted *garbage = NULL;
29789
29790
469
  SAVE_OPLINE();
29791
469
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29792
29793
469
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29794
469
try_assign_dim_array:
29795
469
    SEPARATE_ARRAY(object_ptr);
29796
469
    if (IS_UNUSED == IS_UNUSED) {
29797
469
      value = EX_VAR((opline+1)->op1.var);
29798
469
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29799
197
        HashTable *ht = Z_ARRVAL_P(object_ptr);
29800
197
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29801
197
          GC_ADDREF(ht);
29802
197
        }
29803
197
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29804
197
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29805
0
          zend_array_destroy(ht);
29806
0
          goto assign_dim_error;
29807
0
        }
29808
197
      }
29809
469
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
29810
469
        ZVAL_DEREF(value);
29811
469
      }
29812
469
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29813
469
      if (UNEXPECTED(value == NULL)) {
29814
0
        zend_cannot_add_element();
29815
0
        goto assign_dim_error;
29816
469
      } else if (IS_CV == IS_CV) {
29817
469
        if (Z_REFCOUNTED_P(value)) {
29818
51
          Z_ADDREF_P(value);
29819
51
        }
29820
469
      } else if (IS_CV == IS_VAR) {
29821
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
29822
0
        if (Z_ISREF_P(free_op_data)) {
29823
0
          if (Z_REFCOUNTED_P(value)) {
29824
0
            Z_ADDREF_P(value);
29825
0
          }
29826
0
          zval_ptr_dtor_nogc(free_op_data);
29827
0
        }
29828
0
      } else if (IS_CV == IS_CONST) {
29829
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29830
0
          Z_ADDREF_P(value);
29831
0
        }
29832
0
      }
29833
469
    } else {
29834
0
      dim = NULL;
29835
0
      if (IS_UNUSED == IS_CONST) {
29836
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29837
0
      } else {
29838
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29839
0
      }
29840
0
      if (UNEXPECTED(variable_ptr == NULL)) {
29841
0
        goto assign_dim_error;
29842
0
      }
29843
0
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
29844
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
29845
0
    }
29846
469
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29847
56
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29848
56
    }
29849
469
    if (garbage) {
29850
0
      GC_DTOR_NO_REF(garbage);
29851
0
    }
29852
469
  } else {
29853
229
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
29854
0
      object_ptr = Z_REFVAL_P(object_ptr);
29855
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29856
0
        goto try_assign_dim_array;
29857
0
      }
29858
0
    }
29859
229
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29860
0
      zend_object *obj = Z_OBJ_P(object_ptr);
29861
29862
0
      GC_ADDREF(obj);
29863
0
      dim = NULL;
29864
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29865
0
        dim = ZVAL_UNDEFINED_OP2();
29866
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29867
0
        dim++;
29868
0
      }
29869
29870
0
      value = EX_VAR((opline+1)->op1.var);
29871
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29872
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29873
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
29874
0
        ZVAL_DEREF(value);
29875
0
      }
29876
29877
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29878
29879
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29880
0
        zend_objects_store_del(obj);
29881
0
      }
29882
229
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29883
0
      if (IS_UNUSED == IS_UNUSED) {
29884
0
        zend_use_new_element_for_string();
29885
29886
0
        UNDEF_RESULT();
29887
0
      } else {
29888
0
        dim = NULL;
29889
0
        value = EX_VAR((opline+1)->op1.var);
29890
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29891
29892
0
      }
29893
229
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29894
229
      if (Z_ISREF_P(orig_object_ptr)
29895
229
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29896
229
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29897
0
        dim = NULL;
29898
29899
0
        UNDEF_RESULT();
29900
229
      } else {
29901
229
        HashTable *ht = zend_new_array(8);
29902
229
        uint8_t old_type = Z_TYPE_P(object_ptr);
29903
29904
229
        ZVAL_ARR(object_ptr, ht);
29905
229
        if (UNEXPECTED(old_type == IS_FALSE)) {
29906
0
          GC_ADDREF(ht);
29907
0
          zend_false_to_array_deprecated();
29908
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29909
0
            zend_array_destroy(ht);
29910
0
            goto assign_dim_error;
29911
0
          }
29912
0
        }
29913
229
        goto try_assign_dim_array;
29914
229
      }
29915
229
    } else {
29916
0
      zend_use_scalar_as_array();
29917
0
      dim = NULL;
29918
0
assign_dim_error:
29919
29920
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29921
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29922
0
      }
29923
0
    }
29924
229
  }
29925
469
  if (IS_UNUSED != IS_UNUSED) {
29926
29927
0
  }
29928
469
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29929
  /* assign_dim has two opcodes! */
29930
469
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29931
469
}
29932
29933
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29934
0
{
29935
0
  USE_OPLINE
29936
0
  zval *function_name;
29937
0
  zend_class_entry *ce;
29938
0
  uint32_t call_info;
29939
0
  zend_function *fbc;
29940
0
  zend_execute_data *call;
29941
29942
0
  SAVE_OPLINE();
29943
29944
0
  if (IS_VAR == IS_CONST) {
29945
    /* no function found. try a static method in class */
29946
0
    ce = CACHED_PTR(opline->result.num);
29947
0
    if (UNEXPECTED(ce == NULL)) {
29948
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
29949
0
      if (UNEXPECTED(ce == NULL)) {
29950
29951
0
        HANDLE_EXCEPTION();
29952
0
      }
29953
0
      if (IS_UNUSED != IS_CONST) {
29954
0
        CACHE_PTR(opline->result.num, ce);
29955
0
      }
29956
0
    }
29957
0
  } else if (IS_VAR == IS_UNUSED) {
29958
0
    ce = zend_fetch_class(NULL, opline->op1.num);
29959
0
    if (UNEXPECTED(ce == NULL)) {
29960
29961
0
      HANDLE_EXCEPTION();
29962
0
    }
29963
0
  } else {
29964
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
29965
0
  }
29966
29967
0
  if (IS_VAR == IS_CONST &&
29968
0
      IS_UNUSED == IS_CONST &&
29969
0
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
29970
    /* nothing to do */
29971
0
  } else if (IS_VAR != IS_CONST &&
29972
0
             IS_UNUSED == IS_CONST &&
29973
0
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
29974
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
29975
0
  } else if (IS_UNUSED != IS_UNUSED) {
29976
0
    function_name = NULL;
29977
0
    if (IS_UNUSED != IS_CONST) {
29978
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
29979
0
        do {
29980
0
          if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
29981
0
            function_name = Z_REFVAL_P(function_name);
29982
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
29983
0
              break;
29984
0
            }
29985
0
          } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
29986
0
            ZVAL_UNDEFINED_OP2();
29987
0
            if (UNEXPECTED(EG(exception) != NULL)) {
29988
0
              HANDLE_EXCEPTION();
29989
0
            }
29990
0
          }
29991
0
          zend_throw_error(NULL, "Method name must be a string");
29992
29993
0
          HANDLE_EXCEPTION();
29994
0
        } while (0);
29995
0
      }
29996
0
    }
29997
29998
0
    if (ce->get_static_method) {
29999
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
30000
0
    } else {
30001
0
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
30002
0
    }
30003
0
    if (UNEXPECTED(fbc == NULL)) {
30004
0
      if (EXPECTED(!EG(exception))) {
30005
0
        zend_undefined_method(ce, Z_STR_P(function_name));
30006
0
      }
30007
30008
0
      HANDLE_EXCEPTION();
30009
0
    }
30010
0
    if (IS_UNUSED == IS_CONST &&
30011
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
30012
0
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
30013
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
30014
0
    }
30015
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
30016
0
      init_func_run_time_cache(&fbc->op_array);
30017
0
    }
30018
0
    if (IS_UNUSED != IS_CONST) {
30019
30020
0
    }
30021
0
  } else {
30022
0
    if (UNEXPECTED(ce->constructor == NULL)) {
30023
0
      zend_throw_error(NULL, "Cannot call constructor");
30024
0
      HANDLE_EXCEPTION();
30025
0
    }
30026
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
30027
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
30028
0
      HANDLE_EXCEPTION();
30029
0
    }
30030
0
    fbc = ce->constructor;
30031
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
30032
0
      init_func_run_time_cache(&fbc->op_array);
30033
0
    }
30034
0
  }
30035
30036
0
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
30037
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
30038
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
30039
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
30040
0
    } else {
30041
0
      zend_non_static_method_call(fbc);
30042
0
      HANDLE_EXCEPTION();
30043
0
    }
30044
0
  } else {
30045
    /* previous opcode is ZEND_FETCH_CLASS */
30046
0
    if (IS_VAR == IS_UNUSED
30047
0
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
30048
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
30049
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
30050
0
        ce = Z_OBJCE(EX(This));
30051
0
      } else {
30052
0
        ce = Z_CE(EX(This));
30053
0
      }
30054
0
    }
30055
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
30056
0
  }
30057
30058
0
  call = zend_vm_stack_push_call_frame(call_info,
30059
0
    fbc, opline->extended_value, ce);
30060
0
  call->prev_execute_data = EX(call);
30061
0
  EX(call) = call;
30062
30063
0
  ZEND_VM_NEXT_OPCODE();
30064
0
}
30065
30066
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30067
255
{
30068
255
  if (IS_VAR == IS_UNUSED) {
30069
0
    SAVE_OPLINE();
30070
0
    zend_verify_missing_return_type(EX(func));
30071
0
    HANDLE_EXCEPTION();
30072
255
  } else {
30073
/* prevents "undefined variable opline" errors */
30074
255
#if 0 || (IS_VAR != IS_UNUSED)
30075
255
    USE_OPLINE
30076
255
    zval *retval_ref, *retval_ptr;
30077
255
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
30078
255
    retval_ref = retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30079
30080
255
    if (IS_VAR == IS_CONST) {
30081
0
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
30082
0
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
30083
255
    } else if (IS_VAR == IS_VAR) {
30084
255
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
30085
20
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
30086
20
      }
30087
255
      ZVAL_DEREF(retval_ptr);
30088
255
    } else if (IS_VAR == IS_CV) {
30089
0
      ZVAL_DEREF(retval_ptr);
30090
0
    }
30091
30092
255
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
30093
93
      ZEND_VM_NEXT_OPCODE();
30094
93
    }
30095
30096
162
    if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
30097
0
      SAVE_OPLINE();
30098
0
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
30099
0
      if (UNEXPECTED(EG(exception))) {
30100
0
        HANDLE_EXCEPTION();
30101
0
      }
30102
0
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
30103
0
        ZEND_VM_NEXT_OPCODE();
30104
0
      }
30105
0
    }
30106
30107
162
    zend_reference *ref = NULL;
30108
162
    if (UNEXPECTED(retval_ref != retval_ptr)) {
30109
0
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
30110
0
        ref = Z_REF_P(retval_ref);
30111
0
      } else {
30112
        /* A cast might happen - unwrap the reference if this is a by-value return */
30113
0
        if (Z_REFCOUNT_P(retval_ref) == 1) {
30114
0
          ZVAL_UNREF(retval_ref);
30115
0
        } else {
30116
0
          Z_DELREF_P(retval_ref);
30117
0
          ZVAL_COPY(retval_ref, retval_ptr);
30118
0
        }
30119
0
        retval_ptr = retval_ref;
30120
0
      }
30121
0
    }
30122
30123
162
    SAVE_OPLINE();
30124
162
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
30125
49
      zend_verify_return_error(EX(func), retval_ptr);
30126
49
      HANDLE_EXCEPTION();
30127
49
    }
30128
113
    ZEND_VM_NEXT_OPCODE();
30129
113
#endif
30130
113
  }
30131
255
}
30132
30133
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30134
163k
{
30135
163k
  USE_OPLINE
30136
163k
  zval *varptr, *arg;
30137
30138
163k
  if (IS_UNUSED == IS_CONST) {
30139
0
    SAVE_OPLINE();
30140
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30141
0
    uint32_t arg_num;
30142
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30143
0
    if (UNEXPECTED(!arg)) {
30144
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30145
0
      HANDLE_EXCEPTION();
30146
0
    }
30147
163k
  } else {
30148
163k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30149
163k
  }
30150
30151
163k
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30152
163k
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30153
0
    SAVE_OPLINE();
30154
0
    ZVAL_UNDEFINED_OP1();
30155
0
    ZVAL_NULL(arg);
30156
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30157
0
  }
30158
30159
163k
  if (IS_VAR == IS_CV) {
30160
0
    ZVAL_COPY_DEREF(arg, varptr);
30161
163k
  } else /* if (IS_VAR == IS_VAR) */ {
30162
163k
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
30163
227
      zend_refcounted *ref = Z_COUNTED_P(varptr);
30164
30165
227
      varptr = Z_REFVAL_P(varptr);
30166
227
      ZVAL_COPY_VALUE(arg, varptr);
30167
227
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30168
55
        efree_size(ref, sizeof(zend_reference));
30169
172
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
30170
73
        Z_ADDREF_P(arg);
30171
73
      }
30172
162k
    } else {
30173
162k
      ZVAL_COPY_VALUE(arg, varptr);
30174
162k
    }
30175
163k
  }
30176
30177
163k
  ZEND_VM_NEXT_OPCODE();
30178
163k
}
30179
30180
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30181
249
{
30182
249
  USE_OPLINE
30183
249
  zval *varptr, *arg;
30184
30185
249
  if (IS_UNUSED == IS_CONST) {
30186
0
    SAVE_OPLINE();
30187
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30188
0
    uint32_t arg_num;
30189
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30190
0
    if (UNEXPECTED(!arg)) {
30191
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30192
0
      HANDLE_EXCEPTION();
30193
0
    }
30194
249
  } else {
30195
249
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30196
249
  }
30197
30198
249
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30199
249
  ZVAL_COPY_VALUE(arg, varptr);
30200
30201
249
  if (EXPECTED(Z_ISREF_P(varptr))) {
30202
227
    ZEND_VM_NEXT_OPCODE();
30203
227
  }
30204
30205
249
  SAVE_OPLINE();
30206
22
  ZVAL_NEW_REF(arg, arg);
30207
22
  zend_error(E_NOTICE, "Only variables should be passed by reference");
30208
22
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30209
22
}
30210
30211
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30212
0
{
30213
0
  USE_OPLINE
30214
0
  zval *varptr, *arg;
30215
0
  uint32_t arg_num;
30216
30217
0
  if (IS_UNUSED == IS_CONST) {
30218
0
    SAVE_OPLINE();
30219
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30220
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30221
0
    if (UNEXPECTED(!arg)) {
30222
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30223
0
      HANDLE_EXCEPTION();
30224
0
    }
30225
0
  } else {
30226
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30227
0
    arg_num = opline->op2.num;
30228
0
  }
30229
30230
0
  if (EXPECTED(0)) {
30231
0
    if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30232
0
      goto send_var;
30233
0
    }
30234
30235
0
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30236
0
    ZVAL_COPY_VALUE(arg, varptr);
30237
30238
0
    if (EXPECTED(Z_ISREF_P(varptr) ||
30239
0
        QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30240
0
      ZEND_VM_NEXT_OPCODE();
30241
0
    }
30242
0
  } else {
30243
0
    if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30244
0
      goto send_var;
30245
0
    }
30246
30247
0
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30248
0
    ZVAL_COPY_VALUE(arg, varptr);
30249
30250
0
    if (EXPECTED(Z_ISREF_P(varptr) ||
30251
0
        ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30252
0
      ZEND_VM_NEXT_OPCODE();
30253
0
    }
30254
0
  }
30255
30256
0
  SAVE_OPLINE();
30257
0
  ZVAL_NEW_REF(arg, arg);
30258
0
  zend_error(E_NOTICE, "Only variables should be passed by reference");
30259
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30260
30261
0
send_var:
30262
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30263
0
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
30264
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
30265
30266
0
    varptr = Z_REFVAL_P(varptr);
30267
0
    ZVAL_COPY_VALUE(arg, varptr);
30268
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30269
0
      efree_size(ref, sizeof(zend_reference));
30270
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
30271
0
      Z_ADDREF_P(arg);
30272
0
    }
30273
0
  } else {
30274
0
    ZVAL_COPY_VALUE(arg, varptr);
30275
0
  }
30276
0
  ZEND_VM_NEXT_OPCODE();
30277
0
}
30278
30279
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30280
2.06k
{
30281
2.06k
  USE_OPLINE
30282
2.06k
  zval *varptr, *arg;
30283
2.06k
  uint32_t arg_num;
30284
30285
2.06k
  if (IS_UNUSED == IS_CONST) {
30286
0
    SAVE_OPLINE();
30287
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30288
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30289
0
    if (UNEXPECTED(!arg)) {
30290
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30291
0
      HANDLE_EXCEPTION();
30292
0
    }
30293
2.06k
  } else {
30294
2.06k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30295
2.06k
    arg_num = opline->op2.num;
30296
2.06k
  }
30297
30298
2.06k
  if (EXPECTED(1)) {
30299
2.06k
    if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30300
2.05k
      goto send_var;
30301
2.05k
    }
30302
30303
10
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30304
10
    ZVAL_COPY_VALUE(arg, varptr);
30305
30306
10
    if (EXPECTED(Z_ISREF_P(varptr) ||
30307
10
        QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30308
10
      ZEND_VM_NEXT_OPCODE();
30309
10
    }
30310
10
  } else {
30311
0
    if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30312
0
      goto send_var;
30313
0
    }
30314
30315
0
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30316
0
    ZVAL_COPY_VALUE(arg, varptr);
30317
30318
0
    if (EXPECTED(Z_ISREF_P(varptr) ||
30319
0
        ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30320
0
      ZEND_VM_NEXT_OPCODE();
30321
0
    }
30322
0
  }
30323
30324
2.06k
  SAVE_OPLINE();
30325
0
  ZVAL_NEW_REF(arg, arg);
30326
0
  zend_error(E_NOTICE, "Only variables should be passed by reference");
30327
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30328
30329
2.05k
send_var:
30330
2.05k
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30331
2.05k
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
30332
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
30333
30334
0
    varptr = Z_REFVAL_P(varptr);
30335
0
    ZVAL_COPY_VALUE(arg, varptr);
30336
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30337
0
      efree_size(ref, sizeof(zend_reference));
30338
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
30339
0
      Z_ADDREF_P(arg);
30340
0
    }
30341
2.05k
  } else {
30342
2.05k
    ZVAL_COPY_VALUE(arg, varptr);
30343
2.05k
  }
30344
2.05k
  ZEND_VM_NEXT_OPCODE();
30345
2.05k
}
30346
30347
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30348
289
{
30349
289
  USE_OPLINE
30350
289
  zval *varptr, *arg;
30351
30352
289
  SAVE_OPLINE();
30353
289
  if (IS_UNUSED == IS_CONST) {
30354
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30355
0
    uint32_t arg_num;
30356
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30357
0
    if (UNEXPECTED(!arg)) {
30358
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30359
0
      HANDLE_EXCEPTION();
30360
0
    }
30361
289
  } else {
30362
289
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30363
289
  }
30364
30365
289
  varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30366
289
  if (Z_ISREF_P(varptr)) {
30367
91
    Z_ADDREF_P(varptr);
30368
198
  } else {
30369
198
    ZVAL_MAKE_REF_EX(varptr, 2);
30370
198
  }
30371
289
  ZVAL_REF(arg, Z_REF_P(varptr));
30372
30373
289
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30374
289
  ZEND_VM_NEXT_OPCODE();
30375
289
}
30376
30377
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30378
0
{
30379
0
  USE_OPLINE
30380
0
  zval *varptr, *arg;
30381
0
  uint32_t arg_num;
30382
30383
0
  if (IS_UNUSED == IS_CONST) {
30384
0
    SAVE_OPLINE();
30385
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30386
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30387
0
    if (UNEXPECTED(!arg)) {
30388
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30389
0
      HANDLE_EXCEPTION();
30390
0
    }
30391
0
  } else {
30392
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30393
0
    arg_num = opline->op2.num;
30394
0
  }
30395
30396
0
  if (EXPECTED(0)) {
30397
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30398
0
      goto send_var_by_ref;
30399
0
    }
30400
0
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30401
0
send_var_by_ref:
30402
0
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30403
0
    if (Z_ISREF_P(varptr)) {
30404
0
      Z_ADDREF_P(varptr);
30405
0
    } else {
30406
0
      ZVAL_MAKE_REF_EX(varptr, 2);
30407
0
    }
30408
0
    ZVAL_REF(arg, Z_REF_P(varptr));
30409
30410
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30411
0
    ZEND_VM_NEXT_OPCODE();
30412
0
  }
30413
30414
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30415
0
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30416
0
    SAVE_OPLINE();
30417
0
    ZVAL_UNDEFINED_OP1();
30418
0
    ZVAL_NULL(arg);
30419
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30420
0
  }
30421
30422
0
  if (IS_VAR == IS_CV) {
30423
0
    ZVAL_COPY_DEREF(arg, varptr);
30424
0
  } else /* if (IS_VAR == IS_VAR) */ {
30425
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
30426
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
30427
30428
0
      varptr = Z_REFVAL_P(varptr);
30429
0
      ZVAL_COPY_VALUE(arg, varptr);
30430
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30431
0
        efree_size(ref, sizeof(zend_reference));
30432
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
30433
0
        Z_ADDREF_P(arg);
30434
0
      }
30435
0
    } else {
30436
0
      ZVAL_COPY_VALUE(arg, varptr);
30437
0
    }
30438
0
  }
30439
30440
0
  ZEND_VM_NEXT_OPCODE();
30441
0
}
30442
30443
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30444
0
{
30445
0
  USE_OPLINE
30446
0
  zval *varptr, *arg;
30447
0
  uint32_t arg_num;
30448
30449
0
  if (IS_UNUSED == IS_CONST) {
30450
0
    SAVE_OPLINE();
30451
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30452
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30453
0
    if (UNEXPECTED(!arg)) {
30454
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30455
0
      HANDLE_EXCEPTION();
30456
0
    }
30457
0
  } else {
30458
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30459
0
    arg_num = opline->op2.num;
30460
0
  }
30461
30462
0
  if (EXPECTED(1)) {
30463
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30464
0
      goto send_var_by_ref;
30465
0
    }
30466
0
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30467
0
send_var_by_ref:
30468
0
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30469
0
    if (Z_ISREF_P(varptr)) {
30470
0
      Z_ADDREF_P(varptr);
30471
0
    } else {
30472
0
      ZVAL_MAKE_REF_EX(varptr, 2);
30473
0
    }
30474
0
    ZVAL_REF(arg, Z_REF_P(varptr));
30475
30476
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30477
0
    ZEND_VM_NEXT_OPCODE();
30478
0
  }
30479
30480
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30481
0
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30482
0
    SAVE_OPLINE();
30483
0
    ZVAL_UNDEFINED_OP1();
30484
0
    ZVAL_NULL(arg);
30485
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30486
0
  }
30487
30488
0
  if (IS_VAR == IS_CV) {
30489
0
    ZVAL_COPY_DEREF(arg, varptr);
30490
0
  } else /* if (IS_VAR == IS_VAR) */ {
30491
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
30492
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
30493
30494
0
      varptr = Z_REFVAL_P(varptr);
30495
0
      ZVAL_COPY_VALUE(arg, varptr);
30496
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30497
0
        efree_size(ref, sizeof(zend_reference));
30498
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
30499
0
        Z_ADDREF_P(arg);
30500
0
      }
30501
0
    } else {
30502
0
      ZVAL_COPY_VALUE(arg, varptr);
30503
0
    }
30504
0
  }
30505
30506
0
  ZEND_VM_NEXT_OPCODE();
30507
0
}
30508
30509
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30510
1.10k
{
30511
1.10k
  USE_OPLINE
30512
1.10k
  zval *varptr, *arg;
30513
30514
1.10k
  if (IS_UNUSED == IS_CONST) {
30515
    // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
30516
0
    SAVE_OPLINE();
30517
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30518
0
    uint32_t arg_num;
30519
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30520
0
    if (UNEXPECTED(!arg)) {
30521
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30522
0
      HANDLE_EXCEPTION();
30523
0
    }
30524
1.10k
  } else {
30525
1.10k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30526
1.10k
  }
30527
30528
1.10k
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
30529
51
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30530
51
    if (Z_ISREF_P(varptr)) {
30531
10
      Z_ADDREF_P(varptr);
30532
41
    } else {
30533
41
      ZVAL_MAKE_REF_EX(varptr, 2);
30534
41
    }
30535
51
    ZVAL_REF(arg, Z_REF_P(varptr));
30536
30537
51
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30538
51
    ZEND_VM_NEXT_OPCODE();
30539
51
  }
30540
30541
1.05k
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30542
30543
1.05k
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
30544
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
30545
30546
0
    varptr = Z_REFVAL_P(varptr);
30547
0
    ZVAL_COPY_VALUE(arg, varptr);
30548
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30549
0
      efree_size(ref, sizeof(zend_reference));
30550
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
30551
0
      Z_ADDREF_P(arg);
30552
0
    }
30553
1.05k
  } else {
30554
1.05k
    ZVAL_COPY_VALUE(arg, varptr);
30555
1.05k
  }
30556
30557
1.05k
  ZEND_VM_NEXT_OPCODE();
30558
1.05k
}
30559
30560
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30561
1.94k
{
30562
1.94k
  USE_OPLINE
30563
1.94k
  zval *result;
30564
1.94k
  zend_function *constructor;
30565
1.94k
  zend_class_entry *ce;
30566
1.94k
  zend_execute_data *call;
30567
30568
1.94k
  SAVE_OPLINE();
30569
1.94k
  if (IS_VAR == IS_CONST) {
30570
0
    ce = CACHED_PTR(opline->op2.num);
30571
0
    if (UNEXPECTED(ce == NULL)) {
30572
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
30573
0
      if (UNEXPECTED(ce == NULL)) {
30574
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
30575
0
        HANDLE_EXCEPTION();
30576
0
      }
30577
0
      CACHE_PTR(opline->op2.num, ce);
30578
0
    }
30579
1.94k
  } else if (IS_VAR == IS_UNUSED) {
30580
0
    ce = zend_fetch_class(NULL, opline->op1.num);
30581
0
    if (UNEXPECTED(ce == NULL)) {
30582
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
30583
0
      HANDLE_EXCEPTION();
30584
0
    }
30585
1.94k
  } else {
30586
1.94k
    ce = Z_CE_P(EX_VAR(opline->op1.var));
30587
1.94k
  }
30588
30589
1.94k
  result = EX_VAR(opline->result.var);
30590
1.94k
  if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
30591
58
    ZVAL_UNDEF(result);
30592
58
    HANDLE_EXCEPTION();
30593
58
  }
30594
30595
1.88k
  constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
30596
1.88k
  if (constructor == NULL) {
30597
    /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
30598
     * opcode is DO_FCALL in case EXT instructions are used. */
30599
1.12k
    if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
30600
1.10k
      ZEND_VM_NEXT_OPCODE_EX(1, 2);
30601
1.10k
    }
30602
30603
21
    if (UNEXPECTED(EG(exception))) {
30604
0
      HANDLE_EXCEPTION();
30605
0
    }
30606
30607
    /* Perform a dummy function call */
30608
21
    call = zend_vm_stack_push_call_frame(
30609
21
      ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
30610
21
      opline->extended_value, NULL);
30611
765
  } else {
30612
765
    if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
30613
100
      init_func_run_time_cache(&constructor->op_array);
30614
100
    }
30615
    /* We are not handling overloaded classes right now */
30616
765
    call = zend_vm_stack_push_call_frame(
30617
765
      ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
30618
765
      constructor,
30619
765
      opline->extended_value,
30620
765
      Z_OBJ_P(result));
30621
765
    Z_ADDREF_P(result);
30622
765
  }
30623
30624
786
  call->prev_execute_data = EX(call);
30625
786
  EX(call) = call;
30626
786
  ZEND_VM_NEXT_OPCODE();
30627
786
}
30628
30629
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30630
2.17k
{
30631
2.17k
  USE_OPLINE
30632
2.17k
  zval *expr_ptr, new_expr;
30633
30634
2.17k
  SAVE_OPLINE();
30635
2.17k
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
30636
2.17k
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
30637
51
    expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30638
51
    if (Z_ISREF_P(expr_ptr)) {
30639
35
      Z_ADDREF_P(expr_ptr);
30640
35
    } else {
30641
16
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
30642
16
    }
30643
51
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30644
2.12k
  } else {
30645
2.12k
    expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30646
2.12k
    if (IS_VAR == IS_TMP_VAR) {
30647
      /* pass */
30648
2.12k
    } else if (IS_VAR == IS_CONST) {
30649
0
      Z_TRY_ADDREF_P(expr_ptr);
30650
2.12k
    } else if (IS_VAR == IS_CV) {
30651
0
      ZVAL_DEREF(expr_ptr);
30652
0
      Z_TRY_ADDREF_P(expr_ptr);
30653
2.12k
    } else /* if (IS_VAR == IS_VAR) */ {
30654
2.12k
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
30655
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
30656
30657
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
30658
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30659
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
30660
0
          expr_ptr = &new_expr;
30661
0
          efree_size(ref, sizeof(zend_reference));
30662
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
30663
0
          Z_ADDREF_P(expr_ptr);
30664
0
        }
30665
0
      }
30666
2.12k
    }
30667
2.12k
  }
30668
30669
2.17k
  if (IS_UNUSED != IS_UNUSED) {
30670
0
    zval *offset = NULL;
30671
0
    zend_string *str;
30672
0
    zend_ulong hval;
30673
30674
0
add_again:
30675
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
30676
0
      str = Z_STR_P(offset);
30677
0
      if (IS_UNUSED != IS_CONST) {
30678
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
30679
0
          goto num_index;
30680
0
        }
30681
0
      }
30682
0
str_index:
30683
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
30684
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
30685
0
      hval = Z_LVAL_P(offset);
30686
0
num_index:
30687
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
30688
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
30689
0
      offset = Z_REFVAL_P(offset);
30690
0
      goto add_again;
30691
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
30692
0
      str = ZSTR_EMPTY_ALLOC();
30693
0
      goto str_index;
30694
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
30695
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
30696
0
      goto num_index;
30697
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
30698
0
      hval = 0;
30699
0
      goto num_index;
30700
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
30701
0
      hval = 1;
30702
0
      goto num_index;
30703
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
30704
0
      zend_use_resource_as_offset(offset);
30705
0
      hval = Z_RES_HANDLE_P(offset);
30706
0
      goto num_index;
30707
0
    } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
30708
0
      ZVAL_UNDEFINED_OP2();
30709
0
      str = ZSTR_EMPTY_ALLOC();
30710
0
      goto str_index;
30711
0
    } else {
30712
0
      zend_illegal_array_offset_access(offset);
30713
0
      zval_ptr_dtor_nogc(expr_ptr);
30714
0
    }
30715
30716
2.17k
  } else {
30717
2.17k
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
30718
5
      zend_cannot_add_element();
30719
5
      zval_ptr_dtor_nogc(expr_ptr);
30720
5
    }
30721
2.17k
  }
30722
2.17k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30723
2.17k
}
30724
30725
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30726
1.15k
{
30727
1.15k
  zval *array;
30728
1.15k
  uint32_t size;
30729
1.15k
  USE_OPLINE
30730
30731
1.15k
  SAVE_OPLINE();
30732
1.15k
  array = EX_VAR(opline->result.var);
30733
1.15k
  if (IS_VAR != IS_UNUSED) {
30734
1.15k
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
30735
1.15k
    ZVAL_ARR(array, zend_new_array(size));
30736
    /* Explicitly initialize array as not-packed if flag is set */
30737
1.15k
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
30738
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
30739
0
    }
30740
1.15k
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30741
1.15k
  } else {
30742
0
    ZVAL_ARR(array, zend_new_array(0));
30743
0
    ZEND_VM_NEXT_OPCODE();
30744
0
  }
30745
1.15k
}
30746
30747
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30748
585
{
30749
585
  USE_OPLINE
30750
585
  zval *var_ptr;
30751
30752
585
  var_ptr = EX_VAR(opline->op1.var);
30753
585
  if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
30754
72
    if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) {
30755
21
      ZVAL_UNREF(var_ptr);
30756
21
    }
30757
72
  }
30758
30759
585
  ZEND_VM_NEXT_OPCODE();
30760
585
}
30761
30762
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30763
209
{
30764
209
  USE_OPLINE
30765
30766
209
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
30767
30768
209
  SAVE_OPLINE();
30769
209
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
30770
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30771
0
  }
30772
30773
  /* Destroy the previously yielded value */
30774
209
  zval_ptr_dtor(&generator->value);
30775
30776
  /* Destroy the previously yielded key */
30777
209
  zval_ptr_dtor(&generator->key);
30778
30779
  /* Set the new yielded value */
30780
209
  if (IS_VAR != IS_UNUSED) {
30781
209
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
30782
      /* Constants and temporary variables aren't yieldable by reference,
30783
       * but we still allow them with a notice. */
30784
57
      if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
30785
0
        zval *value;
30786
30787
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30788
30789
0
        value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30790
0
        ZVAL_COPY_VALUE(&generator->value, value);
30791
0
        if (IS_VAR == IS_CONST) {
30792
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30793
0
            Z_ADDREF(generator->value);
30794
0
          }
30795
0
        }
30796
57
      } else {
30797
57
        zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30798
30799
        /* If a function call result is yielded and the function did
30800
         * not return by reference we throw a notice. */
30801
57
        do {
30802
57
          if (IS_VAR == IS_VAR) {
30803
57
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
30804
57
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
30805
57
             && !Z_ISREF_P(value_ptr)) {
30806
5
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30807
5
              ZVAL_COPY(&generator->value, value_ptr);
30808
5
              break;
30809
5
            }
30810
57
          }
30811
52
          if (Z_ISREF_P(value_ptr)) {
30812
45
            Z_ADDREF_P(value_ptr);
30813
45
          } else {
30814
7
            ZVAL_MAKE_REF_EX(value_ptr, 2);
30815
7
          }
30816
52
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
30817
52
        } while (0);
30818
30819
57
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30820
57
      }
30821
152
    } else {
30822
152
      zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30823
30824
      /* Consts, temporary variables and references need copying */
30825
152
      if (IS_VAR == IS_CONST) {
30826
0
        ZVAL_COPY_VALUE(&generator->value, value);
30827
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30828
0
          Z_ADDREF(generator->value);
30829
0
        }
30830
152
      } else if (IS_VAR == IS_TMP_VAR) {
30831
0
        ZVAL_COPY_VALUE(&generator->value, value);
30832
152
      } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
30833
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
30834
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30835
152
      } else {
30836
152
        ZVAL_COPY_VALUE(&generator->value, value);
30837
152
        if (IS_VAR == IS_CV) {
30838
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
30839
0
        }
30840
152
      }
30841
152
    }
30842
209
  } else {
30843
    /* If no value was specified yield null */
30844
0
    ZVAL_NULL(&generator->value);
30845
0
  }
30846
30847
  /* Set the new yielded key */
30848
209
  if (IS_UNUSED != IS_UNUSED) {
30849
0
    zval *key = NULL;
30850
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
30851
0
      key = Z_REFVAL_P(key);
30852
0
    }
30853
0
    ZVAL_COPY(&generator->key, key);
30854
30855
0
    if (Z_TYPE(generator->key) == IS_LONG
30856
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
30857
0
    ) {
30858
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
30859
0
    }
30860
209
  } else {
30861
    /* If no key was specified we use auto-increment keys */
30862
209
    generator->largest_used_integer_key++;
30863
209
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
30864
209
  }
30865
30866
209
  if (RETURN_VALUE_USED(opline)) {
30867
    /* If the return value of yield is used set the send
30868
     * target and initialize it to NULL */
30869
12
    generator->send_target = EX_VAR(opline->result.var);
30870
12
    ZVAL_NULL(generator->send_target);
30871
197
  } else {
30872
197
    generator->send_target = NULL;
30873
197
  }
30874
30875
  /* The GOTO VM uses a local opline variable. We need to set the opline
30876
   * variable in execute_data so we don't resume at an old position. */
30877
209
  SAVE_OPLINE();
30878
30879
209
  ZEND_VM_RETURN();
30880
209
}
30881
30882
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30883
2.36k
{
30884
2.36k
  USE_OPLINE
30885
2.36k
  zval *op1 = EX_VAR(opline->op1.var);
30886
30887
2.36k
  if (IS_VAR == IS_CV) {
30888
0
    if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
30889
0
      ZVAL_NEW_EMPTY_REF(op1);
30890
0
      Z_SET_REFCOUNT_P(op1, 2);
30891
0
      ZVAL_NULL(Z_REFVAL_P(op1));
30892
0
      ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30893
0
    } else {
30894
0
      if (Z_ISREF_P(op1)) {
30895
0
        Z_ADDREF_P(op1);
30896
0
      } else {
30897
0
        ZVAL_MAKE_REF_EX(op1, 2);
30898
0
      }
30899
0
      ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30900
0
    }
30901
2.36k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
30902
2.18k
    op1 = Z_INDIRECT_P(op1);
30903
2.18k
    if (EXPECTED(!Z_ISREF_P(op1))) {
30904
1.48k
      ZVAL_MAKE_REF_EX(op1, 2);
30905
1.48k
    } else {
30906
708
      GC_ADDREF(Z_REF_P(op1));
30907
708
    }
30908
2.18k
    ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30909
2.18k
  } else {
30910
177
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
30911
177
  }
30912
2.36k
  ZEND_VM_NEXT_OPCODE();
30913
2.36k
}
30914
30915
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30916
7
{
30917
7
  USE_OPLINE
30918
7
  zval *op1;
30919
7
  zend_string *type;
30920
30921
7
  SAVE_OPLINE();
30922
7
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30923
7
  type = zend_zval_get_legacy_type(op1);
30924
7
  if (EXPECTED(type)) {
30925
7
    ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
30926
7
  } else {
30927
0
    ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
30928
0
  }
30929
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30930
7
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30931
7
}
30932
30933
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30934
82
{
30935
82
  USE_OPLINE
30936
82
  zval *varptr, *arg;
30937
82
  uint32_t arg_num = opline->op2.num;
30938
30939
82
  if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30940
0
    ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30941
0
  }
30942
30943
82
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30944
82
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30945
30946
82
  if (IS_VAR == IS_CV) {
30947
0
    ZVAL_COPY(arg, varptr);
30948
82
  } else /* if (IS_VAR == IS_VAR) */ {
30949
82
    ZVAL_COPY_VALUE(arg, varptr);
30950
82
  }
30951
30952
82
  ZEND_VM_NEXT_OPCODE();
30953
82
}
30954
30955
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30956
0
{
30957
0
  USE_OPLINE
30958
0
  zval *op1, *op2;
30959
0
  bool result;
30960
30961
0
  SAVE_OPLINE();
30962
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30963
0
  op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30964
0
  result = fast_is_identical_function(op1, op2);
30965
30966
0
  ZEND_VM_SMART_BRANCH(result, 1);
30967
0
}
30968
30969
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30970
0
{
30971
0
  USE_OPLINE
30972
0
  zval *object;
30973
0
  zval *property;
30974
0
  zval *value;
30975
0
  zval *zptr;
30976
0
  void *_cache_slot[3] = {0};
30977
0
  void **cache_slot;
30978
0
  zend_property_info *prop_info;
30979
0
  zend_object *zobj;
30980
0
  zend_string *name, *tmp_name;
30981
30982
0
  SAVE_OPLINE();
30983
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30984
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30985
30986
0
  do {
30987
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30988
30989
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30990
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30991
0
        object = Z_REFVAL_P(object);
30992
0
        goto assign_op_object;
30993
0
      }
30994
0
      if (IS_VAR == IS_CV
30995
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30996
0
        ZVAL_UNDEFINED_OP1();
30997
0
      }
30998
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30999
0
      break;
31000
0
    }
31001
31002
0
assign_op_object:
31003
    /* here we are sure we are dealing with an object */
31004
0
    zobj = Z_OBJ_P(object);
31005
0
    if (IS_CV == IS_CONST) {
31006
0
      name = Z_STR_P(property);
31007
0
    } else {
31008
0
      name = zval_try_get_tmp_string(property, &tmp_name);
31009
0
      if (UNEXPECTED(!name)) {
31010
0
        UNDEF_RESULT();
31011
0
        break;
31012
0
      }
31013
0
    }
31014
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
31015
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31016
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31017
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31018
0
          ZVAL_NULL(EX_VAR(opline->result.var));
31019
0
        }
31020
0
      } else {
31021
0
        zend_reference *ref;
31022
31023
0
        do {
31024
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
31025
0
            ref = Z_REF_P(zptr);
31026
0
            zptr = Z_REFVAL_P(zptr);
31027
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
31028
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
31029
0
              break;
31030
0
            }
31031
0
          }
31032
31033
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
31034
0
          if (prop_info) {
31035
            /* special case for typed properties */
31036
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
31037
0
          } else {
31038
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
31039
0
          }
31040
0
        } while (0);
31041
31042
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31043
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
31044
0
        }
31045
0
      }
31046
0
    } else {
31047
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
31048
0
    }
31049
0
    if (IS_CV != IS_CONST) {
31050
0
      zend_tmp_string_release(tmp_name);
31051
0
    }
31052
0
  } while (0);
31053
31054
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31055
31056
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31057
  /* assign_obj has two opcodes! */
31058
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31059
0
}
31060
31061
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
31062
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31063
0
{
31064
0
  USE_OPLINE
31065
0
  zval *var_ptr;
31066
0
  zval *value, *container, *dim;
31067
0
  HashTable *ht;
31068
31069
0
  SAVE_OPLINE();
31070
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31071
31072
0
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
31073
0
assign_dim_op_array:
31074
0
    SEPARATE_ARRAY(container);
31075
0
    ht = Z_ARRVAL_P(container);
31076
0
assign_dim_op_new_array:
31077
0
    dim = EX_VAR(opline->op2.var);
31078
0
    if (IS_CV == IS_UNUSED) {
31079
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
31080
0
      if (UNEXPECTED(!var_ptr)) {
31081
0
        zend_cannot_add_element();
31082
0
        goto assign_dim_op_ret_null;
31083
0
      }
31084
0
    } else {
31085
0
      if (IS_CV == IS_CONST) {
31086
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
31087
0
      } else {
31088
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
31089
0
      }
31090
0
      if (UNEXPECTED(!var_ptr)) {
31091
0
        goto assign_dim_op_ret_null;
31092
0
      }
31093
0
    }
31094
31095
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
31096
31097
0
    do {
31098
0
      if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
31099
0
        zend_reference *ref = Z_REF_P(var_ptr);
31100
0
        var_ptr = Z_REFVAL_P(var_ptr);
31101
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
31102
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
31103
0
          break;
31104
0
        }
31105
0
      }
31106
0
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
31107
0
    } while (0);
31108
31109
0
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31110
0
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
31111
0
    }
31112
0
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31113
0
  } else {
31114
0
    if (EXPECTED(Z_ISREF_P(container))) {
31115
0
      container = Z_REFVAL_P(container);
31116
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
31117
0
        goto assign_dim_op_array;
31118
0
      }
31119
0
    }
31120
31121
0
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
31122
0
      zend_object *obj = Z_OBJ_P(container);
31123
31124
0
      dim = EX_VAR(opline->op2.var);
31125
0
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31126
0
        dim++;
31127
0
      }
31128
0
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
31129
0
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
31130
0
      uint8_t old_type;
31131
31132
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
31133
0
        ZVAL_UNDEFINED_OP1();
31134
0
      }
31135
0
      ht = zend_new_array(8);
31136
0
      old_type = Z_TYPE_P(container);
31137
0
      ZVAL_ARR(container, ht);
31138
0
      if (UNEXPECTED(old_type == IS_FALSE)) {
31139
0
        GC_ADDREF(ht);
31140
0
        zend_false_to_array_deprecated();
31141
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31142
0
          zend_array_destroy(ht);
31143
0
          goto assign_dim_op_ret_null;
31144
0
        }
31145
0
      }
31146
0
      goto assign_dim_op_new_array;
31147
0
    } else {
31148
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31149
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
31150
0
assign_dim_op_ret_null:
31151
0
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31152
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31153
0
        ZVAL_NULL(EX_VAR(opline->result.var));
31154
0
      }
31155
0
    }
31156
0
  }
31157
31158
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31159
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31160
0
}
31161
31162
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31163
5.13k
{
31164
5.13k
  USE_OPLINE
31165
5.13k
  zval *var_ptr;
31166
5.13k
  zval *value;
31167
31168
5.13k
  SAVE_OPLINE();
31169
5.13k
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31170
5.13k
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31171
31172
5.13k
  do {
31173
5.13k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
31174
195
      zend_reference *ref = Z_REF_P(var_ptr);
31175
195
      var_ptr = Z_REFVAL_P(var_ptr);
31176
195
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
31177
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
31178
0
        break;
31179
0
      }
31180
195
    }
31181
5.13k
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
31182
5.13k
  } while (0);
31183
31184
5.13k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31185
4.32k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
31186
4.32k
  }
31187
31188
5.13k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31189
5.13k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31190
5.13k
}
31191
31192
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31193
0
{
31194
0
  USE_OPLINE
31195
0
  zval *object;
31196
0
  zval *property;
31197
0
  zval *zptr;
31198
0
  void *_cache_slot[3] = {0};
31199
0
  void **cache_slot;
31200
0
  zend_property_info *prop_info;
31201
0
  zend_object *zobj;
31202
0
  zend_string *name, *tmp_name;
31203
31204
0
  SAVE_OPLINE();
31205
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31206
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31207
31208
0
  do {
31209
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31210
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31211
0
        object = Z_REFVAL_P(object);
31212
0
        goto pre_incdec_object;
31213
0
      }
31214
0
      if (IS_VAR == IS_CV
31215
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31216
0
        ZVAL_UNDEFINED_OP1();
31217
0
      }
31218
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31219
0
      break;
31220
0
    }
31221
31222
0
pre_incdec_object:
31223
    /* here we are sure we are dealing with an object */
31224
0
    zobj = Z_OBJ_P(object);
31225
0
    if (IS_CV == IS_CONST) {
31226
0
      name = Z_STR_P(property);
31227
0
    } else {
31228
0
      name = zval_try_get_tmp_string(property, &tmp_name);
31229
0
      if (UNEXPECTED(!name)) {
31230
0
        UNDEF_RESULT();
31231
0
        break;
31232
0
      }
31233
0
    }
31234
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
31235
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31236
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31237
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31238
0
          ZVAL_NULL(EX_VAR(opline->result.var));
31239
0
        }
31240
0
      } else {
31241
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
31242
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
31243
0
      }
31244
0
    } else {
31245
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
31246
0
    }
31247
0
    if (IS_CV != IS_CONST) {
31248
0
      zend_tmp_string_release(tmp_name);
31249
0
    }
31250
0
  } while (0);
31251
31252
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31253
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31254
0
}
31255
31256
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31257
0
{
31258
0
  USE_OPLINE
31259
0
  zval *object;
31260
0
  zval *property;
31261
0
  zval *zptr;
31262
0
  void *_cache_slot[3] = {0};
31263
0
  void **cache_slot;
31264
0
  zend_property_info *prop_info;
31265
0
  zend_object *zobj;
31266
0
  zend_string *name, *tmp_name;
31267
31268
0
  SAVE_OPLINE();
31269
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31270
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31271
31272
0
  do {
31273
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31274
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31275
0
        object = Z_REFVAL_P(object);
31276
0
        goto post_incdec_object;
31277
0
      }
31278
0
      if (IS_VAR == IS_CV
31279
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31280
0
        ZVAL_UNDEFINED_OP1();
31281
0
      }
31282
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31283
0
      break;
31284
0
    }
31285
31286
0
post_incdec_object:
31287
    /* here we are sure we are dealing with an object */
31288
0
    zobj = Z_OBJ_P(object);
31289
0
    if (IS_CV == IS_CONST) {
31290
0
      name = Z_STR_P(property);
31291
0
    } else {
31292
0
      name = zval_try_get_tmp_string(property, &tmp_name);
31293
0
      if (UNEXPECTED(!name)) {
31294
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
31295
0
        break;
31296
0
      }
31297
0
    }
31298
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
31299
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31300
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31301
0
        ZVAL_NULL(EX_VAR(opline->result.var));
31302
0
      } else {
31303
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
31304
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
31305
0
      }
31306
0
    } else {
31307
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
31308
0
    }
31309
0
    if (IS_CV != IS_CONST) {
31310
0
      zend_tmp_string_release(tmp_name);
31311
0
    }
31312
0
  } while (0);
31313
31314
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31315
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31316
0
}
31317
31318
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31319
466
{
31320
466
  USE_OPLINE
31321
466
  zval *container;
31322
31323
466
  SAVE_OPLINE();
31324
466
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31325
466
  zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31326
31327
466
  if (IS_VAR == IS_VAR) {
31328
466
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31329
466
  }
31330
466
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31331
466
}
31332
31333
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31334
0
{
31335
0
  USE_OPLINE
31336
0
  zval *container;
31337
31338
0
  SAVE_OPLINE();
31339
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31340
0
  zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31341
31342
0
  if (IS_VAR == IS_VAR) {
31343
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31344
0
  }
31345
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31346
0
}
31347
31348
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31349
0
{
31350
#if 0
31351
  USE_OPLINE
31352
#endif
31353
31354
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
31355
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
31356
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31357
0
    }
31358
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31359
0
  } else {
31360
0
    if (IS_CV == IS_UNUSED) {
31361
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31362
0
    }
31363
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31364
0
  }
31365
0
}
31366
31367
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31368
0
{
31369
0
  USE_OPLINE
31370
0
  zval *container;
31371
31372
0
  SAVE_OPLINE();
31373
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31374
0
  zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31375
31376
0
  if (IS_VAR == IS_VAR) {
31377
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31378
0
  }
31379
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31380
0
}
31381
31382
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31383
18
{
31384
18
  USE_OPLINE
31385
18
  zval *property, *container, *result;
31386
31387
18
  SAVE_OPLINE();
31388
31389
18
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31390
18
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31391
18
  result = EX_VAR(opline->result.var);
31392
18
  zend_fetch_property_address(
31393
18
    result, container, IS_VAR, property, IS_CV,
31394
18
    ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
31395
18
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
31396
31397
18
  if (IS_VAR == IS_VAR) {
31398
18
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31399
18
  }
31400
18
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31401
18
}
31402
31403
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31404
0
{
31405
0
  USE_OPLINE
31406
0
  zval *property, *container, *result;
31407
31408
0
  SAVE_OPLINE();
31409
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31410
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31411
0
  result = EX_VAR(opline->result.var);
31412
0
  zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
31413
31414
0
  if (IS_VAR == IS_VAR) {
31415
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31416
0
  }
31417
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31418
0
}
31419
31420
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31421
0
{
31422
#if 0
31423
  USE_OPLINE
31424
#endif
31425
31426
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
31427
    /* Behave like FETCH_OBJ_W */
31428
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
31429
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31430
0
    }
31431
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31432
0
  } else {
31433
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31434
0
  }
31435
0
}
31436
31437
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31438
0
{
31439
0
  USE_OPLINE
31440
0
  zval *container, *property, *result;
31441
31442
0
  SAVE_OPLINE();
31443
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31444
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31445
0
  result = EX_VAR(opline->result.var);
31446
0
  zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
31447
31448
0
  if (IS_VAR == IS_VAR) {
31449
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31450
0
  }
31451
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31452
0
}
31453
31454
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31455
0
{
31456
0
  USE_OPLINE
31457
0
  zval *container, *dim;
31458
31459
0
  SAVE_OPLINE();
31460
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31461
0
  dim = EX_VAR(opline->op2.var);
31462
31463
0
  if (IS_VAR == IS_VAR
31464
0
    && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
31465
0
    && UNEXPECTED(!Z_ISREF_P(container))
31466
0
  ) {
31467
0
    zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
31468
0
    zend_fetch_dimension_address_LIST_r(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
31469
0
  } else {
31470
0
    zend_fetch_dimension_address_W(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
31471
0
  }
31472
31473
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31474
0
}
31475
31476
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31477
2
{
31478
2
  USE_OPLINE
31479
2
  zval *object, *value, tmp;
31480
2
  zend_object *zobj;
31481
2
  zend_string *name, *tmp_name;
31482
2
  zend_refcounted *garbage = NULL;
31483
31484
2
  SAVE_OPLINE();
31485
2
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31486
2
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
31487
31488
2
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31489
2
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31490
0
      object = Z_REFVAL_P(object);
31491
0
      goto assign_object;
31492
0
    }
31493
2
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31494
2
    value = &EG(uninitialized_zval);
31495
2
    goto free_and_exit_assign_obj;
31496
2
  }
31497
31498
0
assign_object:
31499
0
  zobj = Z_OBJ_P(object);
31500
0
  if (IS_CV == IS_CONST) {
31501
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31502
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
31503
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31504
0
      zval *property_val;
31505
0
      zend_property_info *prop_info;
31506
31507
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31508
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31509
31510
0
assign_obj_simple:
31511
0
        property_val = OBJ_PROP(zobj, prop_offset);
31512
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
31513
0
          if (prop_info != NULL) {
31514
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31515
0
            goto free_and_exit_assign_obj;
31516
0
          } else {
31517
0
fast_assign_obj:
31518
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
31519
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31520
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
31521
0
            }
31522
0
            goto exit_assign_obj;
31523
0
          }
31524
0
        }
31525
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31526
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31527
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31528
0
          zobj = zend_lazy_object_init(zobj);
31529
0
          if (!zobj) {
31530
0
            value = &EG(uninitialized_zval);
31531
0
            goto free_and_exit_assign_obj;
31532
0
          }
31533
0
        }
31534
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31535
0
          rebuild_object_properties_internal(zobj);
31536
0
        }
31537
0
        if (EXPECTED(zobj->properties != NULL)) {
31538
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31539
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31540
0
              GC_DELREF(zobj->properties);
31541
0
            }
31542
0
            zobj->properties = zend_array_dup(zobj->properties);
31543
0
          }
31544
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
31545
0
          if (property_val) {
31546
0
            goto fast_assign_obj;
31547
0
          }
31548
0
        }
31549
31550
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31551
0
          if (IS_CONST == IS_CONST) {
31552
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31553
0
              Z_ADDREF_P(value);
31554
0
            }
31555
0
          } else if (IS_CONST != IS_TMP_VAR) {
31556
0
            if (Z_ISREF_P(value)) {
31557
0
              if (IS_CONST == IS_VAR) {
31558
0
                zend_reference *ref = Z_REF_P(value);
31559
0
                if (GC_DELREF(ref) == 0) {
31560
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31561
0
                  efree_size(ref, sizeof(zend_reference));
31562
0
                  value = &tmp;
31563
0
                } else {
31564
0
                  value = Z_REFVAL_P(value);
31565
0
                  Z_TRY_ADDREF_P(value);
31566
0
                }
31567
0
              } else {
31568
0
                value = Z_REFVAL_P(value);
31569
0
                Z_TRY_ADDREF_P(value);
31570
0
              }
31571
0
            } else if (IS_CONST == IS_CV) {
31572
0
              Z_TRY_ADDREF_P(value);
31573
0
            }
31574
0
          }
31575
0
          zend_hash_add_new(zobj->properties, name, value);
31576
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31577
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
31578
0
          }
31579
0
          goto exit_assign_obj;
31580
0
        }
31581
0
      } else {
31582
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31583
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31584
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
31585
0
          prop_offset = prop_info->offset;
31586
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31587
0
            prop_info = NULL;
31588
0
          }
31589
0
          goto assign_obj_simple;
31590
0
        }
31591
        /* Fall through to write_property for hooks. */
31592
0
      }
31593
0
    }
31594
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31595
0
  } else {
31596
0
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31597
0
    if (UNEXPECTED(!name)) {
31598
31599
0
      UNDEF_RESULT();
31600
0
      goto exit_assign_obj;
31601
0
    }
31602
0
  }
31603
31604
0
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
31605
0
    ZVAL_DEREF(value);
31606
0
  }
31607
31608
0
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31609
31610
0
  if (IS_CV != IS_CONST) {
31611
0
    zend_tmp_string_release(tmp_name);
31612
0
  }
31613
31614
2
free_and_exit_assign_obj:
31615
2
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31616
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31617
0
  }
31618
31619
2
exit_assign_obj:
31620
2
  if (garbage) {
31621
0
    GC_DTOR_NO_REF(garbage);
31622
0
  }
31623
31624
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31625
  /* assign_obj has two opcodes! */
31626
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31627
2
}
31628
31629
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31630
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31631
0
{
31632
0
  USE_OPLINE
31633
0
  zval *object, *value, tmp;
31634
0
  zend_object *zobj;
31635
0
  zend_string *name, *tmp_name;
31636
0
  zend_refcounted *garbage = NULL;
31637
31638
0
  SAVE_OPLINE();
31639
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31640
0
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31641
31642
0
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31643
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31644
0
      object = Z_REFVAL_P(object);
31645
0
      goto assign_object;
31646
0
    }
31647
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31648
0
    value = &EG(uninitialized_zval);
31649
0
    goto free_and_exit_assign_obj;
31650
0
  }
31651
31652
0
assign_object:
31653
0
  zobj = Z_OBJ_P(object);
31654
0
  if (IS_CV == IS_CONST) {
31655
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31656
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
31657
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31658
0
      zval *property_val;
31659
0
      zend_property_info *prop_info;
31660
31661
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31662
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31663
31664
0
assign_obj_simple:
31665
0
        property_val = OBJ_PROP(zobj, prop_offset);
31666
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
31667
0
          if (prop_info != NULL) {
31668
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31669
0
            goto free_and_exit_assign_obj;
31670
0
          } else {
31671
0
fast_assign_obj:
31672
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
31673
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31674
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
31675
0
            }
31676
0
            goto exit_assign_obj;
31677
0
          }
31678
0
        }
31679
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31680
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31681
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31682
0
          zobj = zend_lazy_object_init(zobj);
31683
0
          if (!zobj) {
31684
0
            value = &EG(uninitialized_zval);
31685
0
            goto free_and_exit_assign_obj;
31686
0
          }
31687
0
        }
31688
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31689
0
          rebuild_object_properties_internal(zobj);
31690
0
        }
31691
0
        if (EXPECTED(zobj->properties != NULL)) {
31692
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31693
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31694
0
              GC_DELREF(zobj->properties);
31695
0
            }
31696
0
            zobj->properties = zend_array_dup(zobj->properties);
31697
0
          }
31698
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
31699
0
          if (property_val) {
31700
0
            goto fast_assign_obj;
31701
0
          }
31702
0
        }
31703
31704
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31705
0
          if (IS_TMP_VAR == IS_CONST) {
31706
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31707
0
              Z_ADDREF_P(value);
31708
0
            }
31709
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
31710
0
            if (Z_ISREF_P(value)) {
31711
0
              if (IS_TMP_VAR == IS_VAR) {
31712
0
                zend_reference *ref = Z_REF_P(value);
31713
0
                if (GC_DELREF(ref) == 0) {
31714
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31715
0
                  efree_size(ref, sizeof(zend_reference));
31716
0
                  value = &tmp;
31717
0
                } else {
31718
0
                  value = Z_REFVAL_P(value);
31719
0
                  Z_TRY_ADDREF_P(value);
31720
0
                }
31721
0
              } else {
31722
0
                value = Z_REFVAL_P(value);
31723
0
                Z_TRY_ADDREF_P(value);
31724
0
              }
31725
0
            } else if (IS_TMP_VAR == IS_CV) {
31726
0
              Z_TRY_ADDREF_P(value);
31727
0
            }
31728
0
          }
31729
0
          zend_hash_add_new(zobj->properties, name, value);
31730
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31731
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
31732
0
          }
31733
0
          goto exit_assign_obj;
31734
0
        }
31735
0
      } else {
31736
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31737
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31738
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
31739
0
          prop_offset = prop_info->offset;
31740
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31741
0
            prop_info = NULL;
31742
0
          }
31743
0
          goto assign_obj_simple;
31744
0
        }
31745
        /* Fall through to write_property for hooks. */
31746
0
      }
31747
0
    }
31748
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31749
0
  } else {
31750
0
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31751
0
    if (UNEXPECTED(!name)) {
31752
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31753
0
      UNDEF_RESULT();
31754
0
      goto exit_assign_obj;
31755
0
    }
31756
0
  }
31757
31758
0
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
31759
0
    ZVAL_DEREF(value);
31760
0
  }
31761
31762
0
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31763
31764
0
  if (IS_CV != IS_CONST) {
31765
0
    zend_tmp_string_release(tmp_name);
31766
0
  }
31767
31768
0
free_and_exit_assign_obj:
31769
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31770
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31771
0
  }
31772
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31773
0
exit_assign_obj:
31774
0
  if (garbage) {
31775
0
    GC_DTOR_NO_REF(garbage);
31776
0
  }
31777
31778
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31779
  /* assign_obj has two opcodes! */
31780
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31781
0
}
31782
31783
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31784
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31785
0
{
31786
0
  USE_OPLINE
31787
0
  zval *object, *value, tmp;
31788
0
  zend_object *zobj;
31789
0
  zend_string *name, *tmp_name;
31790
0
  zend_refcounted *garbage = NULL;
31791
31792
0
  SAVE_OPLINE();
31793
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31794
0
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31795
31796
0
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31797
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31798
0
      object = Z_REFVAL_P(object);
31799
0
      goto assign_object;
31800
0
    }
31801
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31802
0
    value = &EG(uninitialized_zval);
31803
0
    goto free_and_exit_assign_obj;
31804
0
  }
31805
31806
0
assign_object:
31807
0
  zobj = Z_OBJ_P(object);
31808
0
  if (IS_CV == IS_CONST) {
31809
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31810
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
31811
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31812
0
      zval *property_val;
31813
0
      zend_property_info *prop_info;
31814
31815
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31816
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31817
31818
0
assign_obj_simple:
31819
0
        property_val = OBJ_PROP(zobj, prop_offset);
31820
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
31821
0
          if (prop_info != NULL) {
31822
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31823
0
            goto free_and_exit_assign_obj;
31824
0
          } else {
31825
0
fast_assign_obj:
31826
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
31827
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31828
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
31829
0
            }
31830
0
            goto exit_assign_obj;
31831
0
          }
31832
0
        }
31833
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31834
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31835
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31836
0
          zobj = zend_lazy_object_init(zobj);
31837
0
          if (!zobj) {
31838
0
            value = &EG(uninitialized_zval);
31839
0
            goto free_and_exit_assign_obj;
31840
0
          }
31841
0
        }
31842
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31843
0
          rebuild_object_properties_internal(zobj);
31844
0
        }
31845
0
        if (EXPECTED(zobj->properties != NULL)) {
31846
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31847
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31848
0
              GC_DELREF(zobj->properties);
31849
0
            }
31850
0
            zobj->properties = zend_array_dup(zobj->properties);
31851
0
          }
31852
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
31853
0
          if (property_val) {
31854
0
            goto fast_assign_obj;
31855
0
          }
31856
0
        }
31857
31858
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31859
0
          if (IS_VAR == IS_CONST) {
31860
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31861
0
              Z_ADDREF_P(value);
31862
0
            }
31863
0
          } else if (IS_VAR != IS_TMP_VAR) {
31864
0
            if (Z_ISREF_P(value)) {
31865
0
              if (IS_VAR == IS_VAR) {
31866
0
                zend_reference *ref = Z_REF_P(value);
31867
0
                if (GC_DELREF(ref) == 0) {
31868
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31869
0
                  efree_size(ref, sizeof(zend_reference));
31870
0
                  value = &tmp;
31871
0
                } else {
31872
0
                  value = Z_REFVAL_P(value);
31873
0
                  Z_TRY_ADDREF_P(value);
31874
0
                }
31875
0
              } else {
31876
0
                value = Z_REFVAL_P(value);
31877
0
                Z_TRY_ADDREF_P(value);
31878
0
              }
31879
0
            } else if (IS_VAR == IS_CV) {
31880
0
              Z_TRY_ADDREF_P(value);
31881
0
            }
31882
0
          }
31883
0
          zend_hash_add_new(zobj->properties, name, value);
31884
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31885
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
31886
0
          }
31887
0
          goto exit_assign_obj;
31888
0
        }
31889
0
      } else {
31890
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31891
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31892
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
31893
0
          prop_offset = prop_info->offset;
31894
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31895
0
            prop_info = NULL;
31896
0
          }
31897
0
          goto assign_obj_simple;
31898
0
        }
31899
        /* Fall through to write_property for hooks. */
31900
0
      }
31901
0
    }
31902
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31903
0
  } else {
31904
0
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31905
0
    if (UNEXPECTED(!name)) {
31906
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31907
0
      UNDEF_RESULT();
31908
0
      goto exit_assign_obj;
31909
0
    }
31910
0
  }
31911
31912
0
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
31913
0
    ZVAL_DEREF(value);
31914
0
  }
31915
31916
0
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31917
31918
0
  if (IS_CV != IS_CONST) {
31919
0
    zend_tmp_string_release(tmp_name);
31920
0
  }
31921
31922
0
free_and_exit_assign_obj:
31923
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31924
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31925
0
  }
31926
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31927
0
exit_assign_obj:
31928
0
  if (garbage) {
31929
0
    GC_DTOR_NO_REF(garbage);
31930
0
  }
31931
31932
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31933
  /* assign_obj has two opcodes! */
31934
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31935
0
}
31936
31937
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31938
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31939
5
{
31940
5
  USE_OPLINE
31941
5
  zval *object, *value, tmp;
31942
5
  zend_object *zobj;
31943
5
  zend_string *name, *tmp_name;
31944
5
  zend_refcounted *garbage = NULL;
31945
31946
5
  SAVE_OPLINE();
31947
5
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31948
5
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
31949
31950
5
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31951
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31952
0
      object = Z_REFVAL_P(object);
31953
0
      goto assign_object;
31954
0
    }
31955
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31956
0
    value = &EG(uninitialized_zval);
31957
0
    goto free_and_exit_assign_obj;
31958
0
  }
31959
31960
5
assign_object:
31961
5
  zobj = Z_OBJ_P(object);
31962
5
  if (IS_CV == IS_CONST) {
31963
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31964
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
31965
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31966
0
      zval *property_val;
31967
0
      zend_property_info *prop_info;
31968
31969
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31970
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31971
31972
0
assign_obj_simple:
31973
0
        property_val = OBJ_PROP(zobj, prop_offset);
31974
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
31975
0
          if (prop_info != NULL) {
31976
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31977
0
            goto free_and_exit_assign_obj;
31978
0
          } else {
31979
0
fast_assign_obj:
31980
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31981
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31982
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
31983
0
            }
31984
0
            goto exit_assign_obj;
31985
0
          }
31986
0
        }
31987
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31988
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31989
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31990
0
          zobj = zend_lazy_object_init(zobj);
31991
0
          if (!zobj) {
31992
0
            value = &EG(uninitialized_zval);
31993
0
            goto free_and_exit_assign_obj;
31994
0
          }
31995
0
        }
31996
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31997
0
          rebuild_object_properties_internal(zobj);
31998
0
        }
31999
0
        if (EXPECTED(zobj->properties != NULL)) {
32000
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
32001
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
32002
0
              GC_DELREF(zobj->properties);
32003
0
            }
32004
0
            zobj->properties = zend_array_dup(zobj->properties);
32005
0
          }
32006
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
32007
0
          if (property_val) {
32008
0
            goto fast_assign_obj;
32009
0
          }
32010
0
        }
32011
32012
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
32013
0
          if (IS_CV == IS_CONST) {
32014
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
32015
0
              Z_ADDREF_P(value);
32016
0
            }
32017
0
          } else if (IS_CV != IS_TMP_VAR) {
32018
0
            if (Z_ISREF_P(value)) {
32019
0
              if (IS_CV == IS_VAR) {
32020
0
                zend_reference *ref = Z_REF_P(value);
32021
0
                if (GC_DELREF(ref) == 0) {
32022
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
32023
0
                  efree_size(ref, sizeof(zend_reference));
32024
0
                  value = &tmp;
32025
0
                } else {
32026
0
                  value = Z_REFVAL_P(value);
32027
0
                  Z_TRY_ADDREF_P(value);
32028
0
                }
32029
0
              } else {
32030
0
                value = Z_REFVAL_P(value);
32031
0
                Z_TRY_ADDREF_P(value);
32032
0
              }
32033
0
            } else if (IS_CV == IS_CV) {
32034
0
              Z_TRY_ADDREF_P(value);
32035
0
            }
32036
0
          }
32037
0
          zend_hash_add_new(zobj->properties, name, value);
32038
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32039
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
32040
0
          }
32041
0
          goto exit_assign_obj;
32042
0
        }
32043
0
      } else {
32044
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
32045
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
32046
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
32047
0
          prop_offset = prop_info->offset;
32048
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
32049
0
            prop_info = NULL;
32050
0
          }
32051
0
          goto assign_obj_simple;
32052
0
        }
32053
        /* Fall through to write_property for hooks. */
32054
0
      }
32055
0
    }
32056
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
32057
5
  } else {
32058
5
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
32059
5
    if (UNEXPECTED(!name)) {
32060
32061
0
      UNDEF_RESULT();
32062
0
      goto exit_assign_obj;
32063
0
    }
32064
5
  }
32065
32066
5
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
32067
5
    ZVAL_DEREF(value);
32068
5
  }
32069
32070
5
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
32071
32072
5
  if (IS_CV != IS_CONST) {
32073
5
    zend_tmp_string_release(tmp_name);
32074
5
  }
32075
32076
5
free_and_exit_assign_obj:
32077
5
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
32078
5
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
32079
5
  }
32080
32081
5
exit_assign_obj:
32082
5
  if (garbage) {
32083
0
    GC_DTOR_NO_REF(garbage);
32084
0
  }
32085
32086
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32087
  /* assign_obj has two opcodes! */
32088
5
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32089
5
}
32090
32091
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
32092
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32093
797
{
32094
797
  USE_OPLINE
32095
797
  zval *object_ptr, *orig_object_ptr;
32096
797
  zval *value;
32097
797
  zval *variable_ptr;
32098
797
  zval *dim;
32099
797
  zend_refcounted *garbage = NULL;
32100
32101
797
  SAVE_OPLINE();
32102
797
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32103
32104
797
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32105
770
try_assign_dim_array:
32106
770
    SEPARATE_ARRAY(object_ptr);
32107
770
    if (IS_CV == IS_UNUSED) {
32108
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
32109
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32110
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
32111
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32112
0
          GC_ADDREF(ht);
32113
0
        }
32114
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32115
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32116
0
          zend_array_destroy(ht);
32117
0
          goto assign_dim_error;
32118
0
        }
32119
0
      }
32120
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
32121
0
        ZVAL_DEREF(value);
32122
0
      }
32123
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32124
0
      if (UNEXPECTED(value == NULL)) {
32125
0
        zend_cannot_add_element();
32126
0
        goto assign_dim_error;
32127
0
      } else if (IS_CONST == IS_CV) {
32128
0
        if (Z_REFCOUNTED_P(value)) {
32129
0
          Z_ADDREF_P(value);
32130
0
        }
32131
0
      } else if (IS_CONST == IS_VAR) {
32132
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
32133
0
        if (Z_ISREF_P(free_op_data)) {
32134
0
          if (Z_REFCOUNTED_P(value)) {
32135
0
            Z_ADDREF_P(value);
32136
0
          }
32137
0
          zval_ptr_dtor_nogc(free_op_data);
32138
0
        }
32139
0
      } else if (IS_CONST == IS_CONST) {
32140
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32141
0
          Z_ADDREF_P(value);
32142
0
        }
32143
0
      }
32144
770
    } else {
32145
770
      dim = EX_VAR(opline->op2.var);
32146
770
      if (IS_CV == IS_CONST) {
32147
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32148
770
      } else {
32149
770
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32150
770
      }
32151
770
      if (UNEXPECTED(variable_ptr == NULL)) {
32152
3
        goto assign_dim_error;
32153
3
      }
32154
767
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
32155
767
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
32156
767
    }
32157
767
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32158
9
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32159
9
    }
32160
767
    if (garbage) {
32161
0
      GC_DTOR_NO_REF(garbage);
32162
0
    }
32163
767
  } else {
32164
124
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
32165
0
      object_ptr = Z_REFVAL_P(object_ptr);
32166
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32167
0
        goto try_assign_dim_array;
32168
0
      }
32169
0
    }
32170
124
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32171
0
      zend_object *obj = Z_OBJ_P(object_ptr);
32172
32173
0
      GC_ADDREF(obj);
32174
0
      dim = EX_VAR(opline->op2.var);
32175
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32176
0
        dim = ZVAL_UNDEFINED_OP2();
32177
0
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32178
0
        dim++;
32179
0
      }
32180
32181
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
32182
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32183
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32184
0
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
32185
0
        ZVAL_DEREF(value);
32186
0
      }
32187
32188
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32189
32190
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32191
0
        zend_objects_store_del(obj);
32192
0
      }
32193
124
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32194
19
      if (IS_CV == IS_UNUSED) {
32195
0
        zend_use_new_element_for_string();
32196
32197
0
        UNDEF_RESULT();
32198
19
      } else {
32199
19
        dim = EX_VAR(opline->op2.var);
32200
19
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
32201
19
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32202
32203
19
      }
32204
105
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32205
105
      if (Z_ISREF_P(orig_object_ptr)
32206
105
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32207
105
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32208
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32209
32210
0
        UNDEF_RESULT();
32211
105
      } else {
32212
105
        HashTable *ht = zend_new_array(8);
32213
105
        uint8_t old_type = Z_TYPE_P(object_ptr);
32214
32215
105
        ZVAL_ARR(object_ptr, ht);
32216
105
        if (UNEXPECTED(old_type == IS_FALSE)) {
32217
11
          GC_ADDREF(ht);
32218
11
          zend_false_to_array_deprecated();
32219
11
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32220
8
            zend_array_destroy(ht);
32221
8
            goto assign_dim_error;
32222
8
          }
32223
11
        }
32224
97
        goto try_assign_dim_array;
32225
105
      }
32226
105
    } else {
32227
0
      zend_use_scalar_as_array();
32228
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32229
11
assign_dim_error:
32230
32231
11
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32232
0
        ZVAL_NULL(EX_VAR(opline->result.var));
32233
0
      }
32234
11
    }
32235
124
  }
32236
797
  if (IS_CV != IS_UNUSED) {
32237
32238
797
  }
32239
797
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32240
  /* assign_dim has two opcodes! */
32241
797
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32242
797
}
32243
32244
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32245
2
{
32246
2
  USE_OPLINE
32247
2
  zval *object_ptr, *orig_object_ptr;
32248
2
  zval *value;
32249
2
  zval *variable_ptr;
32250
2
  zval *dim;
32251
2
  zend_refcounted *garbage = NULL;
32252
32253
2
  SAVE_OPLINE();
32254
2
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32255
32256
2
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32257
2
try_assign_dim_array:
32258
2
    SEPARATE_ARRAY(object_ptr);
32259
2
    if (IS_CV == IS_UNUSED) {
32260
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32261
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32262
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
32263
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32264
0
          GC_ADDREF(ht);
32265
0
        }
32266
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32267
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32268
0
          zend_array_destroy(ht);
32269
0
          goto assign_dim_error;
32270
0
        }
32271
0
      }
32272
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
32273
0
        ZVAL_DEREF(value);
32274
0
      }
32275
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32276
0
      if (UNEXPECTED(value == NULL)) {
32277
0
        zend_cannot_add_element();
32278
0
        goto assign_dim_error;
32279
0
      } else if (IS_TMP_VAR == IS_CV) {
32280
0
        if (Z_REFCOUNTED_P(value)) {
32281
0
          Z_ADDREF_P(value);
32282
0
        }
32283
0
      } else if (IS_TMP_VAR == IS_VAR) {
32284
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
32285
0
        if (Z_ISREF_P(free_op_data)) {
32286
0
          if (Z_REFCOUNTED_P(value)) {
32287
0
            Z_ADDREF_P(value);
32288
0
          }
32289
0
          zval_ptr_dtor_nogc(free_op_data);
32290
0
        }
32291
0
      } else if (IS_TMP_VAR == IS_CONST) {
32292
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32293
0
          Z_ADDREF_P(value);
32294
0
        }
32295
0
      }
32296
2
    } else {
32297
2
      dim = EX_VAR(opline->op2.var);
32298
2
      if (IS_CV == IS_CONST) {
32299
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32300
2
      } else {
32301
2
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32302
2
      }
32303
2
      if (UNEXPECTED(variable_ptr == NULL)) {
32304
0
        goto assign_dim_error;
32305
0
      }
32306
2
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32307
2
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
32308
2
    }
32309
2
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32310
2
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32311
2
    }
32312
2
    if (garbage) {
32313
0
      GC_DTOR_NO_REF(garbage);
32314
0
    }
32315
2
  } else {
32316
2
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
32317
0
      object_ptr = Z_REFVAL_P(object_ptr);
32318
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32319
0
        goto try_assign_dim_array;
32320
0
      }
32321
0
    }
32322
2
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32323
0
      zend_object *obj = Z_OBJ_P(object_ptr);
32324
32325
0
      GC_ADDREF(obj);
32326
0
      dim = EX_VAR(opline->op2.var);
32327
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32328
0
        dim = ZVAL_UNDEFINED_OP2();
32329
0
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32330
0
        dim++;
32331
0
      }
32332
32333
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32334
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32335
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32336
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
32337
0
        ZVAL_DEREF(value);
32338
0
      }
32339
32340
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32341
32342
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32343
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32344
0
        zend_objects_store_del(obj);
32345
0
      }
32346
2
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32347
0
      if (IS_CV == IS_UNUSED) {
32348
0
        zend_use_new_element_for_string();
32349
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32350
0
        UNDEF_RESULT();
32351
0
      } else {
32352
0
        dim = EX_VAR(opline->op2.var);
32353
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32354
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32355
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32356
0
      }
32357
2
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32358
2
      if (Z_ISREF_P(orig_object_ptr)
32359
2
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32360
2
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32361
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32362
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32363
0
        UNDEF_RESULT();
32364
2
      } else {
32365
2
        HashTable *ht = zend_new_array(8);
32366
2
        uint8_t old_type = Z_TYPE_P(object_ptr);
32367
32368
2
        ZVAL_ARR(object_ptr, ht);
32369
2
        if (UNEXPECTED(old_type == IS_FALSE)) {
32370
0
          GC_ADDREF(ht);
32371
0
          zend_false_to_array_deprecated();
32372
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32373
0
            zend_array_destroy(ht);
32374
0
            goto assign_dim_error;
32375
0
          }
32376
0
        }
32377
2
        goto try_assign_dim_array;
32378
2
      }
32379
2
    } else {
32380
0
      zend_use_scalar_as_array();
32381
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32382
0
assign_dim_error:
32383
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32384
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32385
0
        ZVAL_NULL(EX_VAR(opline->result.var));
32386
0
      }
32387
0
    }
32388
2
  }
32389
2
  if (IS_CV != IS_UNUSED) {
32390
32391
2
  }
32392
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32393
  /* assign_dim has two opcodes! */
32394
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32395
2
}
32396
32397
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32398
1.02k
{
32399
1.02k
  USE_OPLINE
32400
1.02k
  zval *object_ptr, *orig_object_ptr;
32401
1.02k
  zval *value;
32402
1.02k
  zval *variable_ptr;
32403
1.02k
  zval *dim;
32404
1.02k
  zend_refcounted *garbage = NULL;
32405
32406
1.02k
  SAVE_OPLINE();
32407
1.02k
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32408
32409
1.02k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32410
1.02k
try_assign_dim_array:
32411
1.02k
    SEPARATE_ARRAY(object_ptr);
32412
1.02k
    if (IS_CV == IS_UNUSED) {
32413
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32414
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32415
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
32416
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32417
0
          GC_ADDREF(ht);
32418
0
        }
32419
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32420
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32421
0
          zend_array_destroy(ht);
32422
0
          goto assign_dim_error;
32423
0
        }
32424
0
      }
32425
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
32426
0
        ZVAL_DEREF(value);
32427
0
      }
32428
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32429
0
      if (UNEXPECTED(value == NULL)) {
32430
0
        zend_cannot_add_element();
32431
0
        goto assign_dim_error;
32432
0
      } else if (IS_VAR == IS_CV) {
32433
0
        if (Z_REFCOUNTED_P(value)) {
32434
0
          Z_ADDREF_P(value);
32435
0
        }
32436
0
      } else if (IS_VAR == IS_VAR) {
32437
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
32438
0
        if (Z_ISREF_P(free_op_data)) {
32439
0
          if (Z_REFCOUNTED_P(value)) {
32440
0
            Z_ADDREF_P(value);
32441
0
          }
32442
0
          zval_ptr_dtor_nogc(free_op_data);
32443
0
        }
32444
0
      } else if (IS_VAR == IS_CONST) {
32445
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32446
0
          Z_ADDREF_P(value);
32447
0
        }
32448
0
      }
32449
1.02k
    } else {
32450
1.02k
      dim = EX_VAR(opline->op2.var);
32451
1.02k
      if (IS_CV == IS_CONST) {
32452
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32453
1.02k
      } else {
32454
1.02k
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32455
1.02k
      }
32456
1.02k
      if (UNEXPECTED(variable_ptr == NULL)) {
32457
0
        goto assign_dim_error;
32458
0
      }
32459
1.02k
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32460
1.02k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
32461
1.02k
    }
32462
1.02k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32463
749
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32464
749
    }
32465
1.02k
    if (garbage) {
32466
111
      GC_DTOR_NO_REF(garbage);
32467
111
    }
32468
1.02k
  } else {
32469
133
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
32470
0
      object_ptr = Z_REFVAL_P(object_ptr);
32471
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32472
0
        goto try_assign_dim_array;
32473
0
      }
32474
0
    }
32475
133
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32476
0
      zend_object *obj = Z_OBJ_P(object_ptr);
32477
32478
0
      GC_ADDREF(obj);
32479
0
      dim = EX_VAR(opline->op2.var);
32480
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32481
0
        dim = ZVAL_UNDEFINED_OP2();
32482
0
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32483
0
        dim++;
32484
0
      }
32485
32486
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32487
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32488
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32489
0
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
32490
0
        ZVAL_DEREF(value);
32491
0
      }
32492
32493
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32494
32495
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32496
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32497
0
        zend_objects_store_del(obj);
32498
0
      }
32499
133
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32500
0
      if (IS_CV == IS_UNUSED) {
32501
0
        zend_use_new_element_for_string();
32502
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32503
0
        UNDEF_RESULT();
32504
0
      } else {
32505
0
        dim = EX_VAR(opline->op2.var);
32506
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32507
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32508
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32509
0
      }
32510
133
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32511
133
      if (Z_ISREF_P(orig_object_ptr)
32512
133
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32513
133
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32514
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32515
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32516
0
        UNDEF_RESULT();
32517
133
      } else {
32518
133
        HashTable *ht = zend_new_array(8);
32519
133
        uint8_t old_type = Z_TYPE_P(object_ptr);
32520
32521
133
        ZVAL_ARR(object_ptr, ht);
32522
133
        if (UNEXPECTED(old_type == IS_FALSE)) {
32523
0
          GC_ADDREF(ht);
32524
0
          zend_false_to_array_deprecated();
32525
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32526
0
            zend_array_destroy(ht);
32527
0
            goto assign_dim_error;
32528
0
          }
32529
0
        }
32530
133
        goto try_assign_dim_array;
32531
133
      }
32532
133
    } else {
32533
0
      zend_use_scalar_as_array();
32534
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32535
0
assign_dim_error:
32536
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32537
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32538
0
        ZVAL_NULL(EX_VAR(opline->result.var));
32539
0
      }
32540
0
    }
32541
133
  }
32542
1.02k
  if (IS_CV != IS_UNUSED) {
32543
32544
1.02k
  }
32545
1.02k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32546
  /* assign_dim has two opcodes! */
32547
1.02k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32548
1.02k
}
32549
32550
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32551
563
{
32552
563
  USE_OPLINE
32553
563
  zval *object_ptr, *orig_object_ptr;
32554
563
  zval *value;
32555
563
  zval *variable_ptr;
32556
563
  zval *dim;
32557
563
  zend_refcounted *garbage = NULL;
32558
32559
563
  SAVE_OPLINE();
32560
563
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32561
32562
563
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32563
561
try_assign_dim_array:
32564
561
    SEPARATE_ARRAY(object_ptr);
32565
561
    if (IS_CV == IS_UNUSED) {
32566
0
      value = EX_VAR((opline+1)->op1.var);
32567
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32568
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
32569
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32570
0
          GC_ADDREF(ht);
32571
0
        }
32572
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32573
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32574
0
          zend_array_destroy(ht);
32575
0
          goto assign_dim_error;
32576
0
        }
32577
0
      }
32578
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
32579
0
        ZVAL_DEREF(value);
32580
0
      }
32581
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32582
0
      if (UNEXPECTED(value == NULL)) {
32583
0
        zend_cannot_add_element();
32584
0
        goto assign_dim_error;
32585
0
      } else if (IS_CV == IS_CV) {
32586
0
        if (Z_REFCOUNTED_P(value)) {
32587
0
          Z_ADDREF_P(value);
32588
0
        }
32589
0
      } else if (IS_CV == IS_VAR) {
32590
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
32591
0
        if (Z_ISREF_P(free_op_data)) {
32592
0
          if (Z_REFCOUNTED_P(value)) {
32593
0
            Z_ADDREF_P(value);
32594
0
          }
32595
0
          zval_ptr_dtor_nogc(free_op_data);
32596
0
        }
32597
0
      } else if (IS_CV == IS_CONST) {
32598
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32599
0
          Z_ADDREF_P(value);
32600
0
        }
32601
0
      }
32602
561
    } else {
32603
561
      dim = EX_VAR(opline->op2.var);
32604
561
      if (IS_CV == IS_CONST) {
32605
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32606
561
      } else {
32607
561
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32608
561
      }
32609
561
      if (UNEXPECTED(variable_ptr == NULL)) {
32610
0
        goto assign_dim_error;
32611
0
      }
32612
561
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
32613
561
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32614
561
    }
32615
561
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32616
18
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32617
18
    }
32618
561
    if (garbage) {
32619
26
      GC_DTOR_NO_REF(garbage);
32620
26
    }
32621
561
  } else {
32622
151
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
32623
2
      object_ptr = Z_REFVAL_P(object_ptr);
32624
2
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32625
0
        goto try_assign_dim_array;
32626
0
      }
32627
2
    }
32628
151
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32629
2
      zend_object *obj = Z_OBJ_P(object_ptr);
32630
32631
2
      GC_ADDREF(obj);
32632
2
      dim = EX_VAR(opline->op2.var);
32633
2
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32634
0
        dim = ZVAL_UNDEFINED_OP2();
32635
2
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32636
0
        dim++;
32637
0
      }
32638
32639
2
      value = EX_VAR((opline+1)->op1.var);
32640
2
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32641
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32642
2
      } else if (IS_CV & (IS_CV|IS_VAR)) {
32643
2
        ZVAL_DEREF(value);
32644
2
      }
32645
32646
2
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32647
32648
2
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32649
0
        zend_objects_store_del(obj);
32650
0
      }
32651
149
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32652
0
      if (IS_CV == IS_UNUSED) {
32653
0
        zend_use_new_element_for_string();
32654
32655
0
        UNDEF_RESULT();
32656
0
      } else {
32657
0
        dim = EX_VAR(opline->op2.var);
32658
0
        value = EX_VAR((opline+1)->op1.var);
32659
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32660
32661
0
      }
32662
149
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32663
149
      if (Z_ISREF_P(orig_object_ptr)
32664
149
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32665
149
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32666
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32667
32668
0
        UNDEF_RESULT();
32669
149
      } else {
32670
149
        HashTable *ht = zend_new_array(8);
32671
149
        uint8_t old_type = Z_TYPE_P(object_ptr);
32672
32673
149
        ZVAL_ARR(object_ptr, ht);
32674
149
        if (UNEXPECTED(old_type == IS_FALSE)) {
32675
0
          GC_ADDREF(ht);
32676
0
          zend_false_to_array_deprecated();
32677
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32678
0
            zend_array_destroy(ht);
32679
0
            goto assign_dim_error;
32680
0
          }
32681
0
        }
32682
149
        goto try_assign_dim_array;
32683
149
      }
32684
149
    } else {
32685
0
      zend_use_scalar_as_array();
32686
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32687
0
assign_dim_error:
32688
32689
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32690
0
        ZVAL_NULL(EX_VAR(opline->result.var));
32691
0
      }
32692
0
    }
32693
151
  }
32694
563
  if (IS_CV != IS_UNUSED) {
32695
32696
563
  }
32697
563
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32698
  /* assign_dim has two opcodes! */
32699
563
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32700
563
}
32701
32702
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32703
826
{
32704
826
  USE_OPLINE
32705
826
  zval *value;
32706
826
  zval *variable_ptr;
32707
32708
826
  SAVE_OPLINE();
32709
826
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32710
826
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32711
32712
826
  if (0 || UNEXPECTED(0)) {
32713
0
    zend_refcounted *garbage = NULL;
32714
32715
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32716
0
    if (UNEXPECTED(0)) {
32717
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32718
0
    }
32719
0
    if (garbage) {
32720
0
      GC_DTOR_NO_REF(garbage);
32721
0
    }
32722
826
  } else {
32723
826
    value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32724
826
  }
32725
826
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32726
  /* zend_assign_to_variable() always takes care of op2, never free it! */
32727
32728
826
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32729
826
}
32730
32731
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32732
265
{
32733
265
  USE_OPLINE
32734
265
  zval *value;
32735
265
  zval *variable_ptr;
32736
32737
265
  SAVE_OPLINE();
32738
265
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32739
265
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32740
32741
265
  if (0 || UNEXPECTED(1)) {
32742
265
    zend_refcounted *garbage = NULL;
32743
32744
265
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32745
265
    if (UNEXPECTED(1)) {
32746
265
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32747
265
    }
32748
265
    if (garbage) {
32749
0
      GC_DTOR_NO_REF(garbage);
32750
0
    }
32751
265
  } else {
32752
0
    value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32753
0
  }
32754
265
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32755
  /* zend_assign_to_variable() always takes care of op2, never free it! */
32756
32757
265
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32758
265
}
32759
32760
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32761
6.82k
{
32762
6.82k
  USE_OPLINE
32763
6.82k
  zval *variable_ptr;
32764
6.82k
  zval *value_ptr;
32765
6.82k
  zend_refcounted *garbage = NULL;
32766
32767
6.82k
  SAVE_OPLINE();
32768
6.82k
  value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
32769
6.82k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32770
32771
6.82k
  if (IS_VAR == IS_VAR &&
32772
6.82k
             UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
32773
32774
0
    zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
32775
0
    variable_ptr = &EG(uninitialized_zval);
32776
6.82k
  } else if (IS_CV == IS_VAR &&
32777
6.82k
             opline->extended_value == ZEND_RETURNS_FUNCTION &&
32778
6.82k
         UNEXPECTED(!Z_ISREF_P(value_ptr))) {
32779
32780
0
    variable_ptr = zend_wrong_assign_to_variable_reference(
32781
0
      variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
32782
6.82k
  } else {
32783
6.82k
    zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
32784
6.82k
  }
32785
32786
6.82k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32787
752
    ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
32788
752
  }
32789
32790
6.82k
  if (garbage) {
32791
1.44k
    GC_DTOR(garbage);
32792
1.44k
  }
32793
32794
6.82k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32795
6.82k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32796
6.82k
}
32797
32798
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32799
7
{
32800
7
  USE_OPLINE
32801
7
  zval *property, *container, *value_ptr;
32802
32803
7
  SAVE_OPLINE();
32804
32805
7
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32806
7
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32807
32808
7
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32809
32810
7
  if (1) {
32811
7
    if (IS_VAR == IS_UNUSED) {
32812
0
      if (IS_CV == IS_CONST) {
32813
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32814
0
      } else {
32815
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32816
0
      }
32817
7
    } else {
32818
7
      if (IS_CV == IS_CONST) {
32819
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32820
7
      } else {
32821
7
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32822
7
      }
32823
7
    }
32824
7
  } else {
32825
0
    zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32826
0
  }
32827
32828
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32829
32830
7
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32831
7
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32832
7
}
32833
32834
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
32835
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32836
0
{
32837
0
  USE_OPLINE
32838
0
  zval *property, *container, *value_ptr;
32839
32840
0
  SAVE_OPLINE();
32841
32842
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32843
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32844
32845
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
32846
32847
0
  if (1) {
32848
0
    if (IS_VAR == IS_UNUSED) {
32849
0
      if (IS_CV == IS_CONST) {
32850
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32851
0
      } else {
32852
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32853
0
      }
32854
0
    } else {
32855
0
      if (IS_CV == IS_CONST) {
32856
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32857
0
      } else {
32858
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32859
0
      }
32860
0
    }
32861
0
  } else {
32862
0
    zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32863
0
  }
32864
32865
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32866
32867
32868
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32869
0
}
32870
32871
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
32872
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32873
134
{
32874
134
  USE_OPLINE
32875
134
  zval *function_name;
32876
134
  zend_class_entry *ce;
32877
134
  uint32_t call_info;
32878
134
  zend_function *fbc;
32879
134
  zend_execute_data *call;
32880
32881
134
  SAVE_OPLINE();
32882
32883
134
  if (IS_VAR == IS_CONST) {
32884
    /* no function found. try a static method in class */
32885
0
    ce = CACHED_PTR(opline->result.num);
32886
0
    if (UNEXPECTED(ce == NULL)) {
32887
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
32888
0
      if (UNEXPECTED(ce == NULL)) {
32889
32890
0
        HANDLE_EXCEPTION();
32891
0
      }
32892
0
      if (IS_CV != IS_CONST) {
32893
0
        CACHE_PTR(opline->result.num, ce);
32894
0
      }
32895
0
    }
32896
134
  } else if (IS_VAR == IS_UNUSED) {
32897
0
    ce = zend_fetch_class(NULL, opline->op1.num);
32898
0
    if (UNEXPECTED(ce == NULL)) {
32899
32900
0
      HANDLE_EXCEPTION();
32901
0
    }
32902
134
  } else {
32903
134
    ce = Z_CE_P(EX_VAR(opline->op1.var));
32904
134
  }
32905
32906
134
  if (IS_VAR == IS_CONST &&
32907
134
      IS_CV == IS_CONST &&
32908
134
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
32909
    /* nothing to do */
32910
134
  } else if (IS_VAR != IS_CONST &&
32911
134
             IS_CV == IS_CONST &&
32912
134
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
32913
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
32914
134
  } else if (IS_CV != IS_UNUSED) {
32915
134
    function_name = EX_VAR(opline->op2.var);
32916
134
    if (IS_CV != IS_CONST) {
32917
134
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
32918
15
        do {
32919
15
          if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
32920
0
            function_name = Z_REFVAL_P(function_name);
32921
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
32922
0
              break;
32923
0
            }
32924
15
          } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
32925
5
            ZVAL_UNDEFINED_OP2();
32926
5
            if (UNEXPECTED(EG(exception) != NULL)) {
32927
0
              HANDLE_EXCEPTION();
32928
0
            }
32929
5
          }
32930
15
          zend_throw_error(NULL, "Method name must be a string");
32931
32932
15
          HANDLE_EXCEPTION();
32933
15
        } while (0);
32934
15
      }
32935
134
    }
32936
32937
119
    if (ce->get_static_method) {
32938
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
32939
119
    } else {
32940
119
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
32941
119
    }
32942
119
    if (UNEXPECTED(fbc == NULL)) {
32943
6
      if (EXPECTED(!EG(exception))) {
32944
6
        zend_undefined_method(ce, Z_STR_P(function_name));
32945
6
      }
32946
32947
6
      HANDLE_EXCEPTION();
32948
6
    }
32949
113
    if (IS_CV == IS_CONST &&
32950
113
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
32951
113
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
32952
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
32953
0
    }
32954
113
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32955
0
      init_func_run_time_cache(&fbc->op_array);
32956
0
    }
32957
113
    if (IS_CV != IS_CONST) {
32958
32959
113
    }
32960
113
  } else {
32961
0
    if (UNEXPECTED(ce->constructor == NULL)) {
32962
0
      zend_throw_error(NULL, "Cannot call constructor");
32963
0
      HANDLE_EXCEPTION();
32964
0
    }
32965
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
32966
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
32967
0
      HANDLE_EXCEPTION();
32968
0
    }
32969
0
    fbc = ce->constructor;
32970
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32971
0
      init_func_run_time_cache(&fbc->op_array);
32972
0
    }
32973
0
  }
32974
32975
113
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
32976
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
32977
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
32978
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
32979
0
    } else {
32980
0
      zend_non_static_method_call(fbc);
32981
0
      HANDLE_EXCEPTION();
32982
0
    }
32983
113
  } else {
32984
    /* previous opcode is ZEND_FETCH_CLASS */
32985
113
    if (IS_VAR == IS_UNUSED
32986
113
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
32987
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
32988
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
32989
0
        ce = Z_OBJCE(EX(This));
32990
0
      } else {
32991
0
        ce = Z_CE(EX(This));
32992
0
      }
32993
0
    }
32994
113
    call_info = ZEND_CALL_NESTED_FUNCTION;
32995
113
  }
32996
32997
113
  call = zend_vm_stack_push_call_frame(call_info,
32998
113
    fbc, opline->extended_value, ce);
32999
113
  call->prev_execute_data = EX(call);
33000
113
  EX(call) = call;
33001
33002
113
  ZEND_VM_NEXT_OPCODE();
33003
113
}
33004
33005
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33006
0
{
33007
0
  USE_OPLINE
33008
0
  zval *expr_ptr, new_expr;
33009
33010
0
  SAVE_OPLINE();
33011
0
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
33012
0
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
33013
0
    expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33014
0
    if (Z_ISREF_P(expr_ptr)) {
33015
0
      Z_ADDREF_P(expr_ptr);
33016
0
    } else {
33017
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
33018
0
    }
33019
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33020
0
  } else {
33021
0
    expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33022
0
    if (IS_VAR == IS_TMP_VAR) {
33023
      /* pass */
33024
0
    } else if (IS_VAR == IS_CONST) {
33025
0
      Z_TRY_ADDREF_P(expr_ptr);
33026
0
    } else if (IS_VAR == IS_CV) {
33027
0
      ZVAL_DEREF(expr_ptr);
33028
0
      Z_TRY_ADDREF_P(expr_ptr);
33029
0
    } else /* if (IS_VAR == IS_VAR) */ {
33030
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
33031
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
33032
33033
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
33034
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
33035
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
33036
0
          expr_ptr = &new_expr;
33037
0
          efree_size(ref, sizeof(zend_reference));
33038
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
33039
0
          Z_ADDREF_P(expr_ptr);
33040
0
        }
33041
0
      }
33042
0
    }
33043
0
  }
33044
33045
0
  if (IS_CV != IS_UNUSED) {
33046
0
    zval *offset = EX_VAR(opline->op2.var);
33047
0
    zend_string *str;
33048
0
    zend_ulong hval;
33049
33050
0
add_again:
33051
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
33052
0
      str = Z_STR_P(offset);
33053
0
      if (IS_CV != IS_CONST) {
33054
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
33055
0
          goto num_index;
33056
0
        }
33057
0
      }
33058
0
str_index:
33059
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
33060
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
33061
0
      hval = Z_LVAL_P(offset);
33062
0
num_index:
33063
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
33064
0
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
33065
0
      offset = Z_REFVAL_P(offset);
33066
0
      goto add_again;
33067
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
33068
0
      str = ZSTR_EMPTY_ALLOC();
33069
0
      goto str_index;
33070
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
33071
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
33072
0
      goto num_index;
33073
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
33074
0
      hval = 0;
33075
0
      goto num_index;
33076
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
33077
0
      hval = 1;
33078
0
      goto num_index;
33079
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
33080
0
      zend_use_resource_as_offset(offset);
33081
0
      hval = Z_RES_HANDLE_P(offset);
33082
0
      goto num_index;
33083
0
    } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
33084
0
      ZVAL_UNDEFINED_OP2();
33085
0
      str = ZSTR_EMPTY_ALLOC();
33086
0
      goto str_index;
33087
0
    } else {
33088
0
      zend_illegal_array_offset_access(offset);
33089
0
      zval_ptr_dtor_nogc(expr_ptr);
33090
0
    }
33091
33092
0
  } else {
33093
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
33094
0
      zend_cannot_add_element();
33095
0
      zval_ptr_dtor_nogc(expr_ptr);
33096
0
    }
33097
0
  }
33098
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33099
0
}
33100
33101
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33102
0
{
33103
0
  zval *array;
33104
0
  uint32_t size;
33105
0
  USE_OPLINE
33106
33107
0
  SAVE_OPLINE();
33108
0
  array = EX_VAR(opline->result.var);
33109
0
  if (IS_VAR != IS_UNUSED) {
33110
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
33111
0
    ZVAL_ARR(array, zend_new_array(size));
33112
    /* Explicitly initialize array as not-packed if flag is set */
33113
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
33114
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
33115
0
    }
33116
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33117
0
  } else {
33118
0
    ZVAL_ARR(array, zend_new_array(0));
33119
0
    ZEND_VM_NEXT_OPCODE();
33120
0
  }
33121
0
}
33122
33123
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33124
106
{
33125
106
  USE_OPLINE
33126
106
  zval *container;
33127
106
  zval *offset;
33128
106
  zend_ulong hval;
33129
106
  zend_string *key;
33130
33131
106
  SAVE_OPLINE();
33132
106
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33133
106
  offset = EX_VAR(opline->op2.var);
33134
33135
106
  do {
33136
106
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
33137
24
      HashTable *ht;
33138
33139
24
unset_dim_array:
33140
24
      SEPARATE_ARRAY(container);
33141
24
      ht = Z_ARRVAL_P(container);
33142
24
offset_again:
33143
24
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
33144
12
        key = Z_STR_P(offset);
33145
12
        if (IS_CV != IS_CONST) {
33146
12
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
33147
0
            goto num_index_dim;
33148
0
          }
33149
12
        }
33150
14
str_index_dim:
33151
14
        ZEND_ASSERT(ht != &EG(symbol_table));
33152
14
        zend_hash_del(ht, key);
33153
14
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
33154
10
        hval = Z_LVAL_P(offset);
33155
10
num_index_dim:
33156
10
        zend_hash_index_del(ht, hval);
33157
10
      } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
33158
0
        offset = Z_REFVAL_P(offset);
33159
0
        goto offset_again;
33160
2
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
33161
0
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
33162
0
        goto num_index_dim;
33163
2
      } else if (Z_TYPE_P(offset) == IS_NULL) {
33164
0
        key = ZSTR_EMPTY_ALLOC();
33165
0
        goto str_index_dim;
33166
2
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
33167
0
        hval = 0;
33168
0
        goto num_index_dim;
33169
2
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
33170
0
        hval = 1;
33171
0
        goto num_index_dim;
33172
2
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
33173
0
        zend_use_resource_as_offset(offset);
33174
0
        hval = Z_RES_HANDLE_P(offset);
33175
0
        goto num_index_dim;
33176
2
      } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
33177
2
        ZVAL_UNDEFINED_OP2();
33178
2
        key = ZSTR_EMPTY_ALLOC();
33179
2
        goto str_index_dim;
33180
2
      } else {
33181
0
        zend_illegal_array_offset_unset(offset);
33182
0
      }
33183
24
      break;
33184
82
    } else if (Z_ISREF_P(container)) {
33185
0
      container = Z_REFVAL_P(container);
33186
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
33187
0
        goto unset_dim_array;
33188
0
      }
33189
0
    }
33190
82
    if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33191
0
      container = ZVAL_UNDEFINED_OP1();
33192
0
    }
33193
82
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
33194
0
      offset = ZVAL_UNDEFINED_OP2();
33195
0
    }
33196
82
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33197
82
      if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
33198
0
        offset++;
33199
0
      }
33200
82
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
33201
82
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
33202
0
      zend_throw_error(NULL, "Cannot unset string offsets");
33203
0
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
33204
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
33205
0
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
33206
0
      zend_false_to_array_deprecated();
33207
0
    }
33208
82
  } while (0);
33209
33210
106
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33211
106
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33212
106
}
33213
33214
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33215
0
{
33216
0
  USE_OPLINE
33217
0
  zval *container;
33218
0
  zval *offset;
33219
0
  zend_string *name, *tmp_name;
33220
33221
0
  SAVE_OPLINE();
33222
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33223
0
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
33224
33225
0
  do {
33226
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
33227
0
      if (Z_ISREF_P(container)) {
33228
0
        container = Z_REFVAL_P(container);
33229
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
33230
0
          if (IS_VAR == IS_CV
33231
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33232
0
            ZVAL_UNDEFINED_OP1();
33233
0
          }
33234
0
          break;
33235
0
        }
33236
0
      } else {
33237
0
        break;
33238
0
      }
33239
0
    }
33240
0
    if (IS_CV == IS_CONST) {
33241
0
      name = Z_STR_P(offset);
33242
0
    } else {
33243
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
33244
0
      if (UNEXPECTED(!name)) {
33245
0
        break;
33246
0
      }
33247
0
    }
33248
0
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
33249
0
    if (IS_CV != IS_CONST) {
33250
0
      zend_tmp_string_release(tmp_name);
33251
0
    }
33252
0
  } while (0);
33253
33254
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33255
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33256
0
}
33257
33258
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33259
15
{
33260
15
  USE_OPLINE
33261
33262
15
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
33263
33264
15
  SAVE_OPLINE();
33265
15
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
33266
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33267
0
  }
33268
33269
  /* Destroy the previously yielded value */
33270
15
  zval_ptr_dtor(&generator->value);
33271
33272
  /* Destroy the previously yielded key */
33273
15
  zval_ptr_dtor(&generator->key);
33274
33275
  /* Set the new yielded value */
33276
15
  if (IS_VAR != IS_UNUSED) {
33277
15
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
33278
      /* Constants and temporary variables aren't yieldable by reference,
33279
       * but we still allow them with a notice. */
33280
0
      if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
33281
0
        zval *value;
33282
33283
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33284
33285
0
        value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33286
0
        ZVAL_COPY_VALUE(&generator->value, value);
33287
0
        if (IS_VAR == IS_CONST) {
33288
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
33289
0
            Z_ADDREF(generator->value);
33290
0
          }
33291
0
        }
33292
0
      } else {
33293
0
        zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33294
33295
        /* If a function call result is yielded and the function did
33296
         * not return by reference we throw a notice. */
33297
0
        do {
33298
0
          if (IS_VAR == IS_VAR) {
33299
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
33300
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
33301
0
             && !Z_ISREF_P(value_ptr)) {
33302
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33303
0
              ZVAL_COPY(&generator->value, value_ptr);
33304
0
              break;
33305
0
            }
33306
0
          }
33307
0
          if (Z_ISREF_P(value_ptr)) {
33308
0
            Z_ADDREF_P(value_ptr);
33309
0
          } else {
33310
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
33311
0
          }
33312
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
33313
0
        } while (0);
33314
33315
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33316
0
      }
33317
15
    } else {
33318
15
      zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33319
33320
      /* Consts, temporary variables and references need copying */
33321
15
      if (IS_VAR == IS_CONST) {
33322
0
        ZVAL_COPY_VALUE(&generator->value, value);
33323
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
33324
0
          Z_ADDREF(generator->value);
33325
0
        }
33326
15
      } else if (IS_VAR == IS_TMP_VAR) {
33327
0
        ZVAL_COPY_VALUE(&generator->value, value);
33328
15
      } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
33329
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
33330
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33331
15
      } else {
33332
15
        ZVAL_COPY_VALUE(&generator->value, value);
33333
15
        if (IS_VAR == IS_CV) {
33334
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
33335
0
        }
33336
15
      }
33337
15
    }
33338
15
  } else {
33339
    /* If no value was specified yield null */
33340
0
    ZVAL_NULL(&generator->value);
33341
0
  }
33342
33343
  /* Set the new yielded key */
33344
15
  if (IS_CV != IS_UNUSED) {
33345
15
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
33346
15
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
33347
0
      key = Z_REFVAL_P(key);
33348
0
    }
33349
15
    ZVAL_COPY(&generator->key, key);
33350
33351
15
    if (Z_TYPE(generator->key) == IS_LONG
33352
15
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
33353
15
    ) {
33354
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
33355
0
    }
33356
15
  } else {
33357
    /* If no key was specified we use auto-increment keys */
33358
0
    generator->largest_used_integer_key++;
33359
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
33360
0
  }
33361
33362
15
  if (RETURN_VALUE_USED(opline)) {
33363
    /* If the return value of yield is used set the send
33364
     * target and initialize it to NULL */
33365
3
    generator->send_target = EX_VAR(opline->result.var);
33366
3
    ZVAL_NULL(generator->send_target);
33367
12
  } else {
33368
12
    generator->send_target = NULL;
33369
12
  }
33370
33371
  /* The GOTO VM uses a local opline variable. We need to set the opline
33372
   * variable in execute_data so we don't resume at an old position. */
33373
15
  SAVE_OPLINE();
33374
33375
15
  ZEND_VM_RETURN();
33376
15
}
33377
33378
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33379
2.78k
{
33380
2.78k
  USE_OPLINE
33381
2.78k
  zval *array;
33382
2.78k
  zval *value, *variable_ptr;
33383
2.78k
  uint32_t value_type;
33384
2.78k
  HashTable *fe_ht;
33385
2.78k
  HashPosition pos;
33386
33387
2.78k
  array = EX_VAR(opline->op1.var);
33388
2.78k
  SAVE_OPLINE();
33389
2.78k
  fe_ht = Z_ARRVAL_P(array);
33390
2.78k
  pos = Z_FE_POS_P(array);
33391
2.78k
  if (HT_IS_PACKED(fe_ht)) {
33392
2.77k
    value = fe_ht->arPacked + pos;
33393
2.77k
    while (1) {
33394
2.77k
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33395
        /* reached end of iteration */
33396
300
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33397
300
        ZEND_VM_CONTINUE();
33398
300
      }
33399
2.47k
      value_type = Z_TYPE_INFO_P(value);
33400
2.47k
      ZEND_ASSERT(value_type != IS_INDIRECT);
33401
2.47k
      if (EXPECTED(value_type != IS_UNDEF)) {
33402
2.47k
        break;
33403
2.47k
      }
33404
0
      pos++;
33405
0
      value++;
33406
0
    }
33407
2.47k
    Z_FE_POS_P(array) = pos + 1;
33408
2.47k
    if (0) {
33409
0
      ZVAL_LONG(EX_VAR(opline->result.var), pos);
33410
0
    }
33411
2.47k
  } else {
33412
16
    Bucket *p;
33413
33414
16
    p = fe_ht->arData + pos;
33415
16
    while (1) {
33416
16
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33417
        /* reached end of iteration */
33418
8
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33419
8
        ZEND_VM_CONTINUE();
33420
8
      }
33421
8
      pos++;
33422
8
      value = &p->val;
33423
8
      value_type = Z_TYPE_INFO_P(value);
33424
8
      ZEND_ASSERT(value_type != IS_INDIRECT);
33425
8
      if (EXPECTED(value_type != IS_UNDEF)) {
33426
8
        break;
33427
8
      }
33428
0
      p++;
33429
0
    }
33430
8
    Z_FE_POS_P(array) = pos;
33431
8
    if (0) {
33432
0
      if (!p->key) {
33433
0
        ZVAL_LONG(EX_VAR(opline->result.var), p->h);
33434
0
      } else {
33435
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
33436
0
      }
33437
0
    }
33438
8
  }
33439
33440
2.48k
  variable_ptr = EX_VAR(opline->op2.var);
33441
2.48k
  zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
33442
2.48k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33443
2.48k
}
33444
33445
33446
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33447
791
{
33448
791
  USE_OPLINE
33449
791
  zval *array;
33450
791
  zval *value, *variable_ptr;
33451
791
  uint32_t value_type;
33452
791
  HashTable *fe_ht;
33453
791
  HashPosition pos;
33454
33455
791
  array = EX_VAR(opline->op1.var);
33456
791
  SAVE_OPLINE();
33457
791
  fe_ht = Z_ARRVAL_P(array);
33458
791
  pos = Z_FE_POS_P(array);
33459
791
  if (HT_IS_PACKED(fe_ht)) {
33460
175
    value = fe_ht->arPacked + pos;
33461
175
    while (1) {
33462
175
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33463
        /* reached end of iteration */
33464
54
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33465
54
        ZEND_VM_CONTINUE();
33466
54
      }
33467
121
      value_type = Z_TYPE_INFO_P(value);
33468
121
      ZEND_ASSERT(value_type != IS_INDIRECT);
33469
121
      if (EXPECTED(value_type != IS_UNDEF)) {
33470
121
        break;
33471
121
      }
33472
0
      pos++;
33473
0
      value++;
33474
0
    }
33475
121
    Z_FE_POS_P(array) = pos + 1;
33476
121
    if (1) {
33477
121
      ZVAL_LONG(EX_VAR(opline->result.var), pos);
33478
121
    }
33479
616
  } else {
33480
616
    Bucket *p;
33481
33482
616
    p = fe_ht->arData + pos;
33483
616
    while (1) {
33484
616
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33485
        /* reached end of iteration */
33486
72
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33487
72
        ZEND_VM_CONTINUE();
33488
72
      }
33489
544
      pos++;
33490
544
      value = &p->val;
33491
544
      value_type = Z_TYPE_INFO_P(value);
33492
544
      ZEND_ASSERT(value_type != IS_INDIRECT);
33493
544
      if (EXPECTED(value_type != IS_UNDEF)) {
33494
544
        break;
33495
544
      }
33496
0
      p++;
33497
0
    }
33498
544
    Z_FE_POS_P(array) = pos;
33499
544
    if (1) {
33500
544
      if (!p->key) {
33501
14
        ZVAL_LONG(EX_VAR(opline->result.var), p->h);
33502
530
      } else {
33503
530
        ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
33504
530
      }
33505
544
    }
33506
544
  }
33507
33508
665
  variable_ptr = EX_VAR(opline->op2.var);
33509
665
  zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
33510
665
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33511
665
}
33512
33513
33514
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33515
0
{
33516
0
  USE_OPLINE
33517
0
  zval *obj;
33518
0
  zend_object *zobj;
33519
0
  zend_class_entry *ce, *scope;
33520
0
  zend_function *clone;
33521
0
  zend_object_clone_obj_t clone_call;
33522
33523
0
  SAVE_OPLINE();
33524
0
  obj = &EX(This);
33525
33526
0
  do {
33527
0
    if (IS_UNUSED == IS_CONST ||
33528
0
        (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
33529
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
33530
0
        obj = Z_REFVAL_P(obj);
33531
0
        if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
33532
0
          break;
33533
0
        }
33534
0
      }
33535
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
33536
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
33537
0
        ZVAL_UNDEFINED_OP1();
33538
0
        if (UNEXPECTED(EG(exception) != NULL)) {
33539
0
          HANDLE_EXCEPTION();
33540
0
        }
33541
0
      }
33542
0
      zend_throw_error(NULL, "__clone method called on non-object");
33543
33544
0
      HANDLE_EXCEPTION();
33545
0
    }
33546
0
  } while (0);
33547
33548
0
  zobj = Z_OBJ_P(obj);
33549
0
  ce = zobj->ce;
33550
0
  clone = ce->clone;
33551
0
  clone_call = zobj->handlers->clone_obj;
33552
0
  if (UNEXPECTED(clone_call == NULL)) {
33553
0
    zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
33554
33555
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
33556
0
    HANDLE_EXCEPTION();
33557
0
  }
33558
33559
0
  if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
33560
0
    scope = EX(func)->op_array.scope;
33561
0
    if (clone->common.scope != scope) {
33562
0
      if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
33563
0
       || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
33564
0
        zend_wrong_clone_call(clone, scope);
33565
33566
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33567
0
        HANDLE_EXCEPTION();
33568
0
      }
33569
0
    }
33570
0
  }
33571
33572
0
  ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
33573
33574
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33575
0
}
33576
33577
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33578
312
{
33579
312
  uint32_t fetch_type;
33580
312
  zend_class_entry *called_scope, *scope;
33581
312
  USE_OPLINE
33582
33583
312
  if (IS_UNUSED != IS_UNUSED) {
33584
0
    SAVE_OPLINE();
33585
0
    zval *op = NULL;
33586
0
    if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
33587
0
      ZVAL_DEREF(op);
33588
0
      if (Z_TYPE_P(op) != IS_OBJECT) {
33589
0
        zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
33590
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33591
33592
0
        HANDLE_EXCEPTION();
33593
0
      }
33594
0
    }
33595
33596
0
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
33597
33598
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33599
0
  }
33600
33601
312
  fetch_type = opline->op1.num;
33602
312
  scope = EX(func)->op_array.scope;
33603
312
  if (UNEXPECTED(scope == NULL)) {
33604
20
    SAVE_OPLINE();
33605
20
    zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
33606
20
      fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
33607
20
      fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
33608
20
    ZVAL_UNDEF(EX_VAR(opline->result.var));
33609
20
    HANDLE_EXCEPTION();
33610
20
  }
33611
33612
292
  switch (fetch_type) {
33613
191
    case ZEND_FETCH_CLASS_SELF:
33614
191
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
33615
191
      break;
33616
5
    case ZEND_FETCH_CLASS_PARENT:
33617
5
      if (UNEXPECTED(scope->parent == NULL)) {
33618
5
        SAVE_OPLINE();
33619
5
        zend_throw_error(NULL,
33620
5
          "Cannot use \"parent\" when current class scope has no parent");
33621
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33622
5
        HANDLE_EXCEPTION();
33623
5
      }
33624
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
33625
0
      break;
33626
96
    case ZEND_FETCH_CLASS_STATIC:
33627
96
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
33628
35
        called_scope = Z_OBJCE(EX(This));
33629
61
      } else {
33630
61
        called_scope = Z_CE(EX(This));
33631
61
      }
33632
96
      ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
33633
96
      break;
33634
292
    EMPTY_SWITCH_DEFAULT_CASE()
33635
292
  }
33636
287
  ZEND_VM_NEXT_OPCODE();
33637
287
}
33638
33639
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33640
150
{
33641
150
  USE_OPLINE
33642
150
  zval *object;
33643
150
  zval *property;
33644
150
  zval *value;
33645
150
  zval *zptr;
33646
150
  void *_cache_slot[3] = {0};
33647
150
  void **cache_slot;
33648
150
  zend_property_info *prop_info;
33649
150
  zend_object *zobj;
33650
150
  zend_string *name, *tmp_name;
33651
33652
150
  SAVE_OPLINE();
33653
150
  object = &EX(This);
33654
150
  property = RT_CONSTANT(opline, opline->op2);
33655
33656
150
  do {
33657
150
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
33658
33659
150
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33660
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33661
0
        object = Z_REFVAL_P(object);
33662
0
        goto assign_op_object;
33663
0
      }
33664
0
      if (IS_UNUSED == IS_CV
33665
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33666
0
        ZVAL_UNDEFINED_OP1();
33667
0
      }
33668
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33669
0
      break;
33670
0
    }
33671
33672
150
assign_op_object:
33673
    /* here we are sure we are dealing with an object */
33674
150
    zobj = Z_OBJ_P(object);
33675
150
    if (IS_CONST == IS_CONST) {
33676
150
      name = Z_STR_P(property);
33677
150
    } else {
33678
0
      name = zval_try_get_tmp_string(property, &tmp_name);
33679
0
      if (UNEXPECTED(!name)) {
33680
0
        UNDEF_RESULT();
33681
0
        break;
33682
0
      }
33683
0
    }
33684
150
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
33685
150
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33686
112
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33687
15
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33688
0
          ZVAL_NULL(EX_VAR(opline->result.var));
33689
0
        }
33690
97
      } else {
33691
97
        zend_reference *ref;
33692
33693
97
        do {
33694
97
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
33695
5
            ref = Z_REF_P(zptr);
33696
5
            zptr = Z_REFVAL_P(zptr);
33697
5
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
33698
5
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
33699
5
              break;
33700
5
            }
33701
5
          }
33702
33703
92
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33704
92
          if (prop_info) {
33705
            /* special case for typed properties */
33706
29
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
33707
63
          } else {
33708
63
            zend_binary_op(zptr, zptr, value OPLINE_CC);
33709
63
          }
33710
92
        } while (0);
33711
33712
97
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33713
17
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
33714
17
        }
33715
97
      }
33716
112
    } else {
33717
38
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
33718
38
    }
33719
150
    if (IS_CONST != IS_CONST) {
33720
0
      zend_tmp_string_release(tmp_name);
33721
0
    }
33722
150
  } while (0);
33723
33724
150
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
33725
33726
33727
  /* assign_obj has two opcodes! */
33728
150
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
33729
150
}
33730
33731
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
33732
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33733
833
{
33734
833
  USE_OPLINE
33735
833
  zval *object;
33736
833
  zval *property;
33737
833
  zval *zptr;
33738
833
  void *_cache_slot[3] = {0};
33739
833
  void **cache_slot;
33740
833
  zend_property_info *prop_info;
33741
833
  zend_object *zobj;
33742
833
  zend_string *name, *tmp_name;
33743
33744
833
  SAVE_OPLINE();
33745
833
  object = &EX(This);
33746
833
  property = RT_CONSTANT(opline, opline->op2);
33747
33748
833
  do {
33749
833
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33750
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33751
0
        object = Z_REFVAL_P(object);
33752
0
        goto pre_incdec_object;
33753
0
      }
33754
0
      if (IS_UNUSED == IS_CV
33755
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33756
0
        ZVAL_UNDEFINED_OP1();
33757
0
      }
33758
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33759
0
      break;
33760
0
    }
33761
33762
833
pre_incdec_object:
33763
    /* here we are sure we are dealing with an object */
33764
833
    zobj = Z_OBJ_P(object);
33765
833
    if (IS_CONST == IS_CONST) {
33766
833
      name = Z_STR_P(property);
33767
833
    } else {
33768
0
      name = zval_try_get_tmp_string(property, &tmp_name);
33769
0
      if (UNEXPECTED(!name)) {
33770
0
        UNDEF_RESULT();
33771
0
        break;
33772
0
      }
33773
0
    }
33774
833
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
33775
833
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33776
772
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33777
10
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33778
10
          ZVAL_NULL(EX_VAR(opline->result.var));
33779
10
        }
33780
762
      } else {
33781
762
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
33782
762
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33783
762
      }
33784
772
    } else {
33785
61
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33786
61
    }
33787
833
    if (IS_CONST != IS_CONST) {
33788
0
      zend_tmp_string_release(tmp_name);
33789
0
    }
33790
833
  } while (0);
33791
33792
33793
833
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33794
833
}
33795
33796
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33797
23
{
33798
23
  USE_OPLINE
33799
23
  zval *object;
33800
23
  zval *property;
33801
23
  zval *zptr;
33802
23
  void *_cache_slot[3] = {0};
33803
23
  void **cache_slot;
33804
23
  zend_property_info *prop_info;
33805
23
  zend_object *zobj;
33806
23
  zend_string *name, *tmp_name;
33807
33808
23
  SAVE_OPLINE();
33809
23
  object = &EX(This);
33810
23
  property = RT_CONSTANT(opline, opline->op2);
33811
33812
23
  do {
33813
23
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33814
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33815
0
        object = Z_REFVAL_P(object);
33816
0
        goto post_incdec_object;
33817
0
      }
33818
0
      if (IS_UNUSED == IS_CV
33819
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33820
0
        ZVAL_UNDEFINED_OP1();
33821
0
      }
33822
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33823
0
      break;
33824
0
    }
33825
33826
23
post_incdec_object:
33827
    /* here we are sure we are dealing with an object */
33828
23
    zobj = Z_OBJ_P(object);
33829
23
    if (IS_CONST == IS_CONST) {
33830
23
      name = Z_STR_P(property);
33831
23
    } else {
33832
0
      name = zval_try_get_tmp_string(property, &tmp_name);
33833
0
      if (UNEXPECTED(!name)) {
33834
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33835
0
        break;
33836
0
      }
33837
0
    }
33838
23
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
33839
23
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33840
13
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33841
3
        ZVAL_NULL(EX_VAR(opline->result.var));
33842
10
      } else {
33843
10
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33844
10
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33845
10
      }
33846
13
    } else {
33847
10
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33848
10
    }
33849
23
    if (IS_CONST != IS_CONST) {
33850
0
      zend_tmp_string_release(tmp_name);
33851
0
    }
33852
23
  } while (0);
33853
33854
33855
23
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33856
23
}
33857
33858
static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33859
9.72k
{
33860
9.72k
  USE_OPLINE
33861
9.72k
  zval *container;
33862
9.72k
  void **cache_slot = NULL;
33863
33864
9.72k
  SAVE_OPLINE();
33865
9.72k
  container = &EX(This);
33866
33867
9.72k
  if (IS_UNUSED == IS_CONST ||
33868
9.72k
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33869
0
    do {
33870
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33871
0
        container = Z_REFVAL_P(container);
33872
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33873
0
          break;
33874
0
        }
33875
0
      }
33876
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33877
0
        ZVAL_UNDEFINED_OP1();
33878
0
      }
33879
0
      zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
33880
0
      ZVAL_NULL(EX_VAR(opline->result.var));
33881
0
      goto fetch_obj_r_finish;
33882
0
    } while (0);
33883
0
  }
33884
33885
  /* here we are sure we are dealing with an object */
33886
9.72k
  do {
33887
9.72k
    zend_object *zobj = Z_OBJ_P(container);
33888
9.72k
    zend_string *name, *tmp_name;
33889
9.72k
    zval *retval;
33890
33891
9.72k
    if (IS_CONST == IS_CONST) {
33892
9.72k
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
33893
33894
9.72k
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33895
7.99k
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33896
33897
7.99k
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33898
5.58k
fetch_obj_r_simple:
33899
5.58k
          retval = OBJ_PROP(zobj, prop_offset);
33900
5.58k
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
33901
5.53k
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33902
0
              goto fetch_obj_r_copy;
33903
5.53k
            } else {
33904
5.80k
fetch_obj_r_fast_copy:
33905
5.80k
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33906
5.80k
              ZEND_VM_NEXT_OPCODE();
33907
5.80k
            }
33908
5.53k
          }
33909
5.58k
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
33910
4.05k
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
33911
4.05k
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
33912
2.06k
            prop_offset = prop_info->offset;
33913
2.06k
            goto fetch_obj_r_simple;
33914
2.06k
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
33915
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
33916
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
33917
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
33918
33919
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
33920
0
            if (IS_UNUSED & IS_CV) {
33921
0
              GC_ADDREF(zobj);
33922
0
            }
33923
0
            if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
33924
0
              call_info |= ZEND_CALL_RELEASE_THIS;
33925
0
            }
33926
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
33927
0
            call->prev_execute_data = execute_data;
33928
0
            call->call = NULL;
33929
0
            call->return_value = EX_VAR(opline->result.var);
33930
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
33931
33932
0
            execute_data = call;
33933
0
            EG(current_execute_data) = execute_data;
33934
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
33935
33936
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
33937
            opline = hook->op_array.opcodes;
33938
#else
33939
0
            EX(opline) = hook->op_array.opcodes;
33940
0
#endif
33941
0
            LOAD_OPLINE_EX();
33942
33943
33944
0
            ZEND_VM_ENTER_EX();
33945
0
          }
33946
          /* Fall through to read_property for hooks. */
33947
4.05k
        } else if (EXPECTED(zobj->properties != NULL)) {
33948
266
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
33949
266
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33950
266
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33951
260
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33952
33953
260
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33954
260
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33955
33956
260
              if (EXPECTED(p->key == name) ||
33957
260
                  (EXPECTED(p->h == ZSTR_H(name)) &&
33958
20
                   EXPECTED(p->key != NULL) &&
33959
260
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
33960
260
                retval = &p->val;
33961
260
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33962
0
                  goto fetch_obj_r_copy;
33963
260
                } else {
33964
260
                  goto fetch_obj_r_fast_copy;
33965
260
                }
33966
260
              }
33967
260
            }
33968
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33969
0
          }
33970
6
          retval = zend_hash_find_known_hash(zobj->properties, name);
33971
6
          if (EXPECTED(retval)) {
33972
4
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
33973
4
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
33974
4
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33975
0
              goto fetch_obj_r_copy;
33976
4
            } else {
33977
4
              goto fetch_obj_r_fast_copy;
33978
4
            }
33979
4
          }
33980
6
        }
33981
7.99k
      }
33982
3.91k
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33983
3.91k
    } else {
33984
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33985
0
      if (UNEXPECTED(!name)) {
33986
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33987
0
        break;
33988
0
      }
33989
0
    }
33990
33991
3.91k
#if ZEND_DEBUG
33992
    /* For non-standard object handlers, verify a declared property type in debug builds.
33993
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
33994
3.91k
    zend_property_info *prop_info = NULL;
33995
3.91k
    if (zobj->handlers->read_property != zend_std_read_property) {
33996
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
33997
0
    }
33998
3.91k
#endif
33999
3.91k
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
34000
3.91k
#if ZEND_DEBUG
34001
3.91k
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
34002
3.91k
        && ZEND_TYPE_IS_SET(prop_info->type)) {
34003
0
      ZVAL_OPT_DEREF(retval);
34004
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
34005
0
    }
34006
3.91k
#endif
34007
34008
3.91k
    if (IS_CONST != IS_CONST) {
34009
0
      zend_tmp_string_release(tmp_name);
34010
0
    }
34011
34012
3.91k
    if (retval != EX_VAR(opline->result.var)) {
34013
1.90k
fetch_obj_r_copy:
34014
1.90k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34015
2.01k
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
34016
0
      zend_unwrap_reference(retval);
34017
0
    }
34018
3.91k
  } while (0);
34019
34020
3.91k
fetch_obj_r_finish:
34021
34022
34023
1.94k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34024
1.94k
}
34025
34026
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34027
9.72k
{
34028
9.72k
  ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34029
9.72k
}
34030
34031
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34032
2.87k
{
34033
2.87k
  USE_OPLINE
34034
2.87k
  zval *property, *container, *result;
34035
34036
2.87k
  SAVE_OPLINE();
34037
34038
2.87k
  container = &EX(This);
34039
2.87k
  property = RT_CONSTANT(opline, opline->op2);
34040
2.87k
  result = EX_VAR(opline->result.var);
34041
2.87k
  zend_fetch_property_address(
34042
2.87k
    result, container, IS_UNUSED, property, IS_CONST,
34043
2.87k
    ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
34044
2.87k
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
34045
34046
2.87k
  if (IS_UNUSED == IS_VAR) {
34047
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
34048
0
  }
34049
2.87k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34050
2.87k
}
34051
34052
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34053
0
{
34054
0
  USE_OPLINE
34055
0
  zval *property, *container, *result;
34056
34057
0
  SAVE_OPLINE();
34058
0
  container = &EX(This);
34059
0
  property = RT_CONSTANT(opline, opline->op2);
34060
0
  result = EX_VAR(opline->result.var);
34061
0
  zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
34062
34063
0
  if (IS_UNUSED == IS_VAR) {
34064
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
34065
0
  }
34066
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34067
0
}
34068
34069
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34070
253
{
34071
253
  USE_OPLINE
34072
253
  zval *container;
34073
253
  void **cache_slot = NULL;
34074
34075
253
  SAVE_OPLINE();
34076
253
  container = &EX(This);
34077
34078
253
  if (IS_UNUSED == IS_CONST ||
34079
253
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
34080
0
    do {
34081
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
34082
0
        container = Z_REFVAL_P(container);
34083
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
34084
0
          break;
34085
0
        }
34086
0
      }
34087
0
      if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
34088
0
        ZVAL_UNDEFINED_OP2();
34089
0
      }
34090
0
      ZVAL_NULL(EX_VAR(opline->result.var));
34091
0
      goto fetch_obj_is_finish;
34092
0
    } while (0);
34093
0
  }
34094
34095
  /* here we are sure we are dealing with an object */
34096
253
  do {
34097
253
    zend_object *zobj = Z_OBJ_P(container);
34098
253
    zend_string *name, *tmp_name;
34099
253
    zval *retval;
34100
34101
253
    if (IS_CONST == IS_CONST) {
34102
253
      cache_slot = CACHE_ADDR(opline->extended_value);
34103
34104
253
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
34105
147
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34106
34107
147
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34108
120
fetch_obj_is_simple:
34109
120
          retval = OBJ_PROP(zobj, prop_offset);
34110
120
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
34111
120
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34112
0
              goto fetch_obj_is_copy;
34113
120
            } else {
34114
120
fetch_obj_is_fast_copy:
34115
120
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34116
120
              ZEND_VM_NEXT_OPCODE();
34117
120
            }
34118
120
          }
34119
120
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
34120
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
34121
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
34122
0
            prop_offset = prop_info->offset;
34123
0
            goto fetch_obj_is_simple;
34124
0
          }
34125
          /* Fall through to read_property for hooks. */
34126
27
        } else if (EXPECTED(zobj->properties != NULL)) {
34127
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
34128
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34129
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
34130
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
34131
34132
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
34133
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
34134
34135
0
              if (EXPECTED(p->key == name) ||
34136
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
34137
0
                   EXPECTED(p->key != NULL) &&
34138
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
34139
0
                retval = &p->val;
34140
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34141
0
                  goto fetch_obj_is_copy;
34142
0
                } else {
34143
0
                  goto fetch_obj_is_fast_copy;
34144
0
                }
34145
0
              }
34146
0
            }
34147
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
34148
0
          }
34149
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
34150
0
          if (EXPECTED(retval)) {
34151
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
34152
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
34153
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34154
0
              goto fetch_obj_is_copy;
34155
0
            } else {
34156
0
              goto fetch_obj_is_fast_copy;
34157
0
            }
34158
0
          }
34159
0
        }
34160
147
      }
34161
133
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34162
133
    } else {
34163
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34164
0
      if (UNEXPECTED(!name)) {
34165
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
34166
0
        break;
34167
0
      }
34168
0
    }
34169
34170
133
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
34171
34172
133
    if (IS_CONST != IS_CONST) {
34173
0
      zend_tmp_string_release(tmp_name);
34174
0
    }
34175
34176
133
    if (retval != EX_VAR(opline->result.var)) {
34177
128
fetch_obj_is_copy:
34178
128
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34179
128
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
34180
5
      zend_unwrap_reference(retval);
34181
5
    }
34182
133
  } while (0);
34183
34184
133
fetch_obj_is_finish:
34185
34186
34187
133
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34188
133
}
34189
34190
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34191
68
{
34192
#if 0
34193
  USE_OPLINE
34194
#endif
34195
34196
68
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
34197
    /* Behave like FETCH_OBJ_W */
34198
21
    if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
34199
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34200
0
    }
34201
21
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34202
47
  } else {
34203
47
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34204
47
  }
34205
68
}
34206
34207
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34208
32
{
34209
32
  USE_OPLINE
34210
32
  zval *container, *property, *result;
34211
34212
32
  SAVE_OPLINE();
34213
32
  container = &EX(This);
34214
32
  property = RT_CONSTANT(opline, opline->op2);
34215
32
  result = EX_VAR(opline->result.var);
34216
32
  zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
34217
34218
32
  if (IS_UNUSED == IS_VAR) {
34219
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
34220
0
  }
34221
32
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34222
32
}
34223
34224
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34225
2.97k
{
34226
2.97k
  USE_OPLINE
34227
2.97k
  zval *object, *value, tmp;
34228
2.97k
  zend_object *zobj;
34229
2.97k
  zend_string *name, *tmp_name;
34230
2.97k
  zend_refcounted *garbage = NULL;
34231
34232
2.97k
  SAVE_OPLINE();
34233
2.97k
  object = &EX(This);
34234
2.97k
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
34235
34236
2.97k
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34237
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34238
0
      object = Z_REFVAL_P(object);
34239
0
      goto assign_object;
34240
0
    }
34241
0
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34242
0
    value = &EG(uninitialized_zval);
34243
0
    goto free_and_exit_assign_obj;
34244
0
  }
34245
34246
2.97k
assign_object:
34247
2.97k
  zobj = Z_OBJ_P(object);
34248
2.97k
  if (IS_CONST == IS_CONST) {
34249
2.97k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34250
1.79k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
34251
1.79k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34252
1.79k
      zval *property_val;
34253
1.79k
      zend_property_info *prop_info;
34254
34255
1.79k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34256
1.57k
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34257
34258
1.57k
assign_obj_simple:
34259
1.57k
        property_val = OBJ_PROP(zobj, prop_offset);
34260
1.57k
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
34261
761
          if (prop_info != NULL) {
34262
123
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34263
123
            goto free_and_exit_assign_obj;
34264
638
          } else {
34265
645
fast_assign_obj:
34266
645
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
34267
645
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34268
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
34269
0
            }
34270
645
            goto exit_assign_obj;
34271
638
          }
34272
761
        }
34273
1.57k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34274
168
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34275
168
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34276
0
          zobj = zend_lazy_object_init(zobj);
34277
0
          if (!zobj) {
34278
0
            value = &EG(uninitialized_zval);
34279
0
            goto free_and_exit_assign_obj;
34280
0
          }
34281
0
        }
34282
168
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34283
138
          rebuild_object_properties_internal(zobj);
34284
138
        }
34285
168
        if (EXPECTED(zobj->properties != NULL)) {
34286
145
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34287
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34288
0
              GC_DELREF(zobj->properties);
34289
0
            }
34290
0
            zobj->properties = zend_array_dup(zobj->properties);
34291
0
          }
34292
145
          property_val = zend_hash_find_known_hash(zobj->properties, name);
34293
145
          if (property_val) {
34294
7
            goto fast_assign_obj;
34295
7
          }
34296
145
        }
34297
34298
161
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34299
138
          if (IS_CONST == IS_CONST) {
34300
138
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34301
0
              Z_ADDREF_P(value);
34302
0
            }
34303
138
          } else if (IS_CONST != IS_TMP_VAR) {
34304
0
            if (Z_ISREF_P(value)) {
34305
0
              if (IS_CONST == IS_VAR) {
34306
0
                zend_reference *ref = Z_REF_P(value);
34307
0
                if (GC_DELREF(ref) == 0) {
34308
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34309
0
                  efree_size(ref, sizeof(zend_reference));
34310
0
                  value = &tmp;
34311
0
                } else {
34312
0
                  value = Z_REFVAL_P(value);
34313
0
                  Z_TRY_ADDREF_P(value);
34314
0
                }
34315
0
              } else {
34316
0
                value = Z_REFVAL_P(value);
34317
0
                Z_TRY_ADDREF_P(value);
34318
0
              }
34319
0
            } else if (IS_CONST == IS_CV) {
34320
0
              Z_TRY_ADDREF_P(value);
34321
0
            }
34322
0
          }
34323
138
          zend_hash_add_new(zobj->properties, name, value);
34324
138
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34325
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
34326
0
          }
34327
138
          goto exit_assign_obj;
34328
138
        }
34329
161
      } else {
34330
47
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34331
47
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34332
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
34333
0
          prop_offset = prop_info->offset;
34334
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34335
0
            prop_info = NULL;
34336
0
          }
34337
0
          goto assign_obj_simple;
34338
0
        }
34339
        /* Fall through to write_property for hooks. */
34340
47
      }
34341
1.79k
    }
34342
2.06k
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34343
2.06k
  } else {
34344
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34345
0
    if (UNEXPECTED(!name)) {
34346
34347
0
      UNDEF_RESULT();
34348
0
      goto exit_assign_obj;
34349
0
    }
34350
0
  }
34351
34352
2.06k
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
34353
0
    ZVAL_DEREF(value);
34354
0
  }
34355
34356
2.06k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34357
34358
2.06k
  if (IS_CONST != IS_CONST) {
34359
0
    zend_tmp_string_release(tmp_name);
34360
0
  }
34361
34362
2.18k
free_and_exit_assign_obj:
34363
2.18k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34364
17
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34365
17
  }
34366
34367
2.97k
exit_assign_obj:
34368
2.97k
  if (garbage) {
34369
135
    GC_DTOR_NO_REF(garbage);
34370
135
  }
34371
34372
34373
  /* assign_obj has two opcodes! */
34374
2.97k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34375
2.97k
}
34376
34377
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34378
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34379
4.08k
{
34380
4.08k
  USE_OPLINE
34381
4.08k
  zval *object, *value, tmp;
34382
4.08k
  zend_object *zobj;
34383
4.08k
  zend_string *name, *tmp_name;
34384
4.08k
  zend_refcounted *garbage = NULL;
34385
34386
4.08k
  SAVE_OPLINE();
34387
4.08k
  object = &EX(This);
34388
4.08k
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
34389
34390
4.08k
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34391
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34392
0
      object = Z_REFVAL_P(object);
34393
0
      goto assign_object;
34394
0
    }
34395
0
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34396
0
    value = &EG(uninitialized_zval);
34397
0
    goto free_and_exit_assign_obj;
34398
0
  }
34399
34400
4.08k
assign_object:
34401
4.08k
  zobj = Z_OBJ_P(object);
34402
4.08k
  if (IS_CONST == IS_CONST) {
34403
4.08k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34404
3.79k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
34405
3.79k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34406
3.79k
      zval *property_val;
34407
3.79k
      zend_property_info *prop_info;
34408
34409
3.79k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34410
3.37k
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34411
34412
3.38k
assign_obj_simple:
34413
3.38k
        property_val = OBJ_PROP(zobj, prop_offset);
34414
3.38k
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
34415
3.21k
          if (prop_info != NULL) {
34416
20
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34417
20
            goto free_and_exit_assign_obj;
34418
3.19k
          } else {
34419
3.33k
fast_assign_obj:
34420
3.33k
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
34421
3.33k
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34422
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
34423
0
            }
34424
3.33k
            goto exit_assign_obj;
34425
3.19k
          }
34426
3.21k
        }
34427
3.38k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34428
408
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34429
408
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34430
0
          zobj = zend_lazy_object_init(zobj);
34431
0
          if (!zobj) {
34432
0
            value = &EG(uninitialized_zval);
34433
0
            goto free_and_exit_assign_obj;
34434
0
          }
34435
0
        }
34436
408
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34437
0
          rebuild_object_properties_internal(zobj);
34438
0
        }
34439
408
        if (EXPECTED(zobj->properties != NULL)) {
34440
132
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34441
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34442
0
              GC_DELREF(zobj->properties);
34443
0
            }
34444
0
            zobj->properties = zend_array_dup(zobj->properties);
34445
0
          }
34446
132
          property_val = zend_hash_find_known_hash(zobj->properties, name);
34447
132
          if (property_val) {
34448
132
            goto fast_assign_obj;
34449
132
          }
34450
132
        }
34451
34452
276
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34453
0
          if (IS_TMP_VAR == IS_CONST) {
34454
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34455
0
              Z_ADDREF_P(value);
34456
0
            }
34457
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
34458
0
            if (Z_ISREF_P(value)) {
34459
0
              if (IS_TMP_VAR == IS_VAR) {
34460
0
                zend_reference *ref = Z_REF_P(value);
34461
0
                if (GC_DELREF(ref) == 0) {
34462
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34463
0
                  efree_size(ref, sizeof(zend_reference));
34464
0
                  value = &tmp;
34465
0
                } else {
34466
0
                  value = Z_REFVAL_P(value);
34467
0
                  Z_TRY_ADDREF_P(value);
34468
0
                }
34469
0
              } else {
34470
0
                value = Z_REFVAL_P(value);
34471
0
                Z_TRY_ADDREF_P(value);
34472
0
              }
34473
0
            } else if (IS_TMP_VAR == IS_CV) {
34474
0
              Z_TRY_ADDREF_P(value);
34475
0
            }
34476
0
          }
34477
0
          zend_hash_add_new(zobj->properties, name, value);
34478
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34479
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
34480
0
          }
34481
0
          goto exit_assign_obj;
34482
0
        }
34483
276
      } else {
34484
10
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34485
10
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34486
10
          prop_info = CACHED_PTR_EX(cache_slot + 2);
34487
10
          prop_offset = prop_info->offset;
34488
10
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34489
5
            prop_info = NULL;
34490
5
          }
34491
10
          goto assign_obj_simple;
34492
10
        }
34493
        /* Fall through to write_property for hooks. */
34494
10
      }
34495
3.79k
    }
34496
729
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34497
729
  } else {
34498
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34499
0
    if (UNEXPECTED(!name)) {
34500
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34501
0
      UNDEF_RESULT();
34502
0
      goto exit_assign_obj;
34503
0
    }
34504
0
  }
34505
34506
729
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
34507
0
    ZVAL_DEREF(value);
34508
0
  }
34509
34510
729
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34511
34512
729
  if (IS_CONST != IS_CONST) {
34513
0
    zend_tmp_string_release(tmp_name);
34514
0
  }
34515
34516
749
free_and_exit_assign_obj:
34517
749
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34518
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34519
0
  }
34520
749
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34521
4.08k
exit_assign_obj:
34522
4.08k
  if (garbage) {
34523
161
    GC_DTOR_NO_REF(garbage);
34524
161
  }
34525
34526
34527
  /* assign_obj has two opcodes! */
34528
4.08k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34529
4.08k
}
34530
34531
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34532
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34533
680
{
34534
680
  USE_OPLINE
34535
680
  zval *object, *value, tmp;
34536
680
  zend_object *zobj;
34537
680
  zend_string *name, *tmp_name;
34538
680
  zend_refcounted *garbage = NULL;
34539
34540
680
  SAVE_OPLINE();
34541
680
  object = &EX(This);
34542
680
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
34543
34544
680
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34545
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34546
0
      object = Z_REFVAL_P(object);
34547
0
      goto assign_object;
34548
0
    }
34549
0
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34550
0
    value = &EG(uninitialized_zval);
34551
0
    goto free_and_exit_assign_obj;
34552
0
  }
34553
34554
680
assign_object:
34555
680
  zobj = Z_OBJ_P(object);
34556
680
  if (IS_CONST == IS_CONST) {
34557
680
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34558
376
      void **cache_slot = CACHE_ADDR(opline->extended_value);
34559
376
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34560
376
      zval *property_val;
34561
376
      zend_property_info *prop_info;
34562
34563
376
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34564
324
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34565
34566
324
assign_obj_simple:
34567
324
        property_val = OBJ_PROP(zobj, prop_offset);
34568
324
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
34569
81
          if (prop_info != NULL) {
34570
29
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34571
29
            goto free_and_exit_assign_obj;
34572
52
          } else {
34573
65
fast_assign_obj:
34574
65
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
34575
65
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34576
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
34577
0
            }
34578
65
            goto exit_assign_obj;
34579
52
          }
34580
81
        }
34581
324
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34582
52
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34583
52
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34584
0
          zobj = zend_lazy_object_init(zobj);
34585
0
          if (!zobj) {
34586
0
            value = &EG(uninitialized_zval);
34587
0
            goto free_and_exit_assign_obj;
34588
0
          }
34589
0
        }
34590
52
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34591
23
          rebuild_object_properties_internal(zobj);
34592
23
        }
34593
52
        if (EXPECTED(zobj->properties != NULL)) {
34594
46
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34595
14
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34596
14
              GC_DELREF(zobj->properties);
34597
14
            }
34598
14
            zobj->properties = zend_array_dup(zobj->properties);
34599
14
          }
34600
46
          property_val = zend_hash_find_known_hash(zobj->properties, name);
34601
46
          if (property_val) {
34602
13
            goto fast_assign_obj;
34603
13
          }
34604
46
        }
34605
34606
39
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34607
23
          if (IS_VAR == IS_CONST) {
34608
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34609
0
              Z_ADDREF_P(value);
34610
0
            }
34611
23
          } else if (IS_VAR != IS_TMP_VAR) {
34612
23
            if (Z_ISREF_P(value)) {
34613
0
              if (IS_VAR == IS_VAR) {
34614
0
                zend_reference *ref = Z_REF_P(value);
34615
0
                if (GC_DELREF(ref) == 0) {
34616
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34617
0
                  efree_size(ref, sizeof(zend_reference));
34618
0
                  value = &tmp;
34619
0
                } else {
34620
0
                  value = Z_REFVAL_P(value);
34621
0
                  Z_TRY_ADDREF_P(value);
34622
0
                }
34623
0
              } else {
34624
0
                value = Z_REFVAL_P(value);
34625
0
                Z_TRY_ADDREF_P(value);
34626
0
              }
34627
23
            } else if (IS_VAR == IS_CV) {
34628
0
              Z_TRY_ADDREF_P(value);
34629
0
            }
34630
23
          }
34631
23
          zend_hash_add_new(zobj->properties, name, value);
34632
23
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34633
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
34634
0
          }
34635
23
          goto exit_assign_obj;
34636
23
        }
34637
39
      } else {
34638
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34639
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34640
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
34641
0
          prop_offset = prop_info->offset;
34642
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34643
0
            prop_info = NULL;
34644
0
          }
34645
0
          goto assign_obj_simple;
34646
0
        }
34647
        /* Fall through to write_property for hooks. */
34648
0
      }
34649
376
    }
34650
563
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34651
563
  } else {
34652
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34653
0
    if (UNEXPECTED(!name)) {
34654
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34655
0
      UNDEF_RESULT();
34656
0
      goto exit_assign_obj;
34657
0
    }
34658
0
  }
34659
34660
563
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
34661
563
    ZVAL_DEREF(value);
34662
563
  }
34663
34664
563
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34665
34666
563
  if (IS_CONST != IS_CONST) {
34667
0
    zend_tmp_string_release(tmp_name);
34668
0
  }
34669
34670
592
free_and_exit_assign_obj:
34671
592
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34672
12
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34673
12
  }
34674
592
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34675
680
exit_assign_obj:
34676
680
  if (garbage) {
34677
42
    GC_DTOR_NO_REF(garbage);
34678
42
  }
34679
34680
34681
  /* assign_obj has two opcodes! */
34682
680
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34683
680
}
34684
34685
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34686
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34687
4.86k
{
34688
4.86k
  USE_OPLINE
34689
4.86k
  zval *object, *value, tmp;
34690
4.86k
  zend_object *zobj;
34691
4.86k
  zend_string *name, *tmp_name;
34692
4.86k
  zend_refcounted *garbage = NULL;
34693
34694
4.86k
  SAVE_OPLINE();
34695
4.86k
  object = &EX(This);
34696
4.86k
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
34697
34698
4.86k
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34699
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34700
0
      object = Z_REFVAL_P(object);
34701
0
      goto assign_object;
34702
0
    }
34703
0
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34704
0
    value = &EG(uninitialized_zval);
34705
0
    goto free_and_exit_assign_obj;
34706
0
  }
34707
34708
4.86k
assign_object:
34709
4.86k
  zobj = Z_OBJ_P(object);
34710
4.86k
  if (IS_CONST == IS_CONST) {
34711
4.86k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34712
3.37k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
34713
3.37k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34714
3.37k
      zval *property_val;
34715
3.37k
      zend_property_info *prop_info;
34716
34717
3.37k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34718
1.33k
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34719
34720
1.49k
assign_obj_simple:
34721
1.49k
        property_val = OBJ_PROP(zobj, prop_offset);
34722
1.49k
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
34723
1.00k
          if (prop_info != NULL) {
34724
32
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34725
32
            goto free_and_exit_assign_obj;
34726
969
          } else {
34727
1.04k
fast_assign_obj:
34728
1.04k
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
34729
1.04k
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34730
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
34731
0
            }
34732
1.04k
            goto exit_assign_obj;
34733
969
          }
34734
1.00k
        }
34735
2.03k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34736
223
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34737
223
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34738
0
          zobj = zend_lazy_object_init(zobj);
34739
0
          if (!zobj) {
34740
0
            value = &EG(uninitialized_zval);
34741
0
            goto free_and_exit_assign_obj;
34742
0
          }
34743
0
        }
34744
223
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34745
5
          rebuild_object_properties_internal(zobj);
34746
5
        }
34747
223
        if (EXPECTED(zobj->properties != NULL)) {
34748
85
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34749
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34750
0
              GC_DELREF(zobj->properties);
34751
0
            }
34752
0
            zobj->properties = zend_array_dup(zobj->properties);
34753
0
          }
34754
85
          property_val = zend_hash_find_known_hash(zobj->properties, name);
34755
85
          if (property_val) {
34756
80
            goto fast_assign_obj;
34757
80
          }
34758
85
        }
34759
34760
143
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34761
5
          if (IS_CV == IS_CONST) {
34762
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34763
0
              Z_ADDREF_P(value);
34764
0
            }
34765
5
          } else if (IS_CV != IS_TMP_VAR) {
34766
5
            if (Z_ISREF_P(value)) {
34767
0
              if (IS_CV == IS_VAR) {
34768
0
                zend_reference *ref = Z_REF_P(value);
34769
0
                if (GC_DELREF(ref) == 0) {
34770
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34771
0
                  efree_size(ref, sizeof(zend_reference));
34772
0
                  value = &tmp;
34773
0
                } else {
34774
0
                  value = Z_REFVAL_P(value);
34775
0
                  Z_TRY_ADDREF_P(value);
34776
0
                }
34777
0
              } else {
34778
0
                value = Z_REFVAL_P(value);
34779
0
                Z_TRY_ADDREF_P(value);
34780
0
              }
34781
5
            } else if (IS_CV == IS_CV) {
34782
5
              Z_TRY_ADDREF_P(value);
34783
5
            }
34784
5
          }
34785
5
          zend_hash_add_new(zobj->properties, name, value);
34786
5
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34787
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
34788
0
          }
34789
5
          goto exit_assign_obj;
34790
5
        }
34791
1.81k
      } else {
34792
1.81k
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34793
1.81k
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34794
158
          prop_info = CACHED_PTR_EX(cache_slot + 2);
34795
158
          prop_offset = prop_info->offset;
34796
158
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34797
153
            prop_info = NULL;
34798
153
          }
34799
158
          goto assign_obj_simple;
34800
158
        }
34801
        /* Fall through to write_property for hooks. */
34802
1.81k
      }
34803
3.37k
    }
34804
3.77k
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34805
3.77k
  } else {
34806
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34807
0
    if (UNEXPECTED(!name)) {
34808
34809
0
      UNDEF_RESULT();
34810
0
      goto exit_assign_obj;
34811
0
    }
34812
0
  }
34813
34814
3.77k
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
34815
3.77k
    ZVAL_DEREF(value);
34816
3.77k
  }
34817
34818
3.77k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34819
34820
3.77k
  if (IS_CONST != IS_CONST) {
34821
0
    zend_tmp_string_release(tmp_name);
34822
0
  }
34823
34824
3.77k
free_and_exit_assign_obj:
34825
2.14k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34826
7
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34827
7
  }
34828
34829
3.20k
exit_assign_obj:
34830
3.20k
  if (garbage) {
34831
0
    GC_DTOR_NO_REF(garbage);
34832
0
  }
34833
34834
34835
  /* assign_obj has two opcodes! */
34836
3.20k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34837
3.20k
}
34838
34839
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34840
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34841
5
{
34842
5
  USE_OPLINE
34843
5
  zval *property, *container, *value_ptr;
34844
34845
5
  SAVE_OPLINE();
34846
34847
5
  container = &EX(This);
34848
5
  property = RT_CONSTANT(opline, opline->op2);
34849
34850
5
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
34851
34852
5
  if (1) {
34853
5
    if (IS_UNUSED == IS_UNUSED) {
34854
5
      if (IS_CONST == IS_CONST) {
34855
5
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34856
5
      } else {
34857
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34858
0
      }
34859
5
    } else {
34860
0
      if (IS_CONST == IS_CONST) {
34861
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34862
0
      } else {
34863
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34864
0
      }
34865
0
    }
34866
5
  } else {
34867
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34868
0
  }
34869
34870
34871
5
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34872
5
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34873
5
}
34874
34875
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34876
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34877
76
{
34878
76
  USE_OPLINE
34879
76
  zval *property, *container, *value_ptr;
34880
34881
76
  SAVE_OPLINE();
34882
34883
76
  container = &EX(This);
34884
76
  property = RT_CONSTANT(opline, opline->op2);
34885
34886
76
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
34887
34888
76
  if (1) {
34889
76
    if (IS_UNUSED == IS_UNUSED) {
34890
76
      if (IS_CONST == IS_CONST) {
34891
76
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34892
76
      } else {
34893
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34894
0
      }
34895
76
    } else {
34896
0
      if (IS_CONST == IS_CONST) {
34897
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34898
0
      } else {
34899
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34900
0
      }
34901
0
    }
34902
76
  } else {
34903
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34904
0
  }
34905
34906
34907
34908
76
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34909
76
}
34910
34911
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34912
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34913
318k
{
34914
318k
  USE_OPLINE
34915
318k
  zend_string **rope;
34916
318k
  zval *var;
34917
34918
  /* Compiler allocates the necessary number of zval slots to keep the rope */
34919
318k
  rope = (zend_string**)EX_VAR(opline->result.var);
34920
318k
  if (IS_CONST == IS_CONST) {
34921
318k
    var = RT_CONSTANT(opline, opline->op2);
34922
318k
    rope[0] = Z_STR_P(var);
34923
318k
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
34924
3
      Z_ADDREF_P(var);
34925
3
    }
34926
318k
  } else {
34927
0
    var = RT_CONSTANT(opline, opline->op2);
34928
0
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
34929
0
      if (IS_CONST == IS_CV) {
34930
0
        rope[0] = zend_string_copy(Z_STR_P(var));
34931
0
      } else {
34932
0
        rope[0] = Z_STR_P(var);
34933
0
      }
34934
0
    } else {
34935
0
      SAVE_OPLINE();
34936
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
34937
0
        ZVAL_UNDEFINED_OP2();
34938
0
      }
34939
0
      rope[0] = zval_get_string_func(var);
34940
34941
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34942
0
    }
34943
0
  }
34944
318k
  ZEND_VM_NEXT_OPCODE();
34945
318k
}
34946
34947
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34948
0
{
34949
0
  zval *class_name;
34950
0
  USE_OPLINE
34951
34952
0
  SAVE_OPLINE();
34953
0
  if (IS_CONST == IS_UNUSED) {
34954
0
    Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
34955
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34956
0
  } else if (IS_CONST == IS_CONST) {
34957
0
    zend_class_entry *ce = CACHED_PTR(opline->extended_value);
34958
34959
0
    if (UNEXPECTED(ce == NULL)) {
34960
0
      class_name = RT_CONSTANT(opline, opline->op2);
34961
0
      ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
34962
0
      CACHE_PTR(opline->extended_value, ce);
34963
0
    }
34964
0
    Z_CE_P(EX_VAR(opline->result.var)) = ce;
34965
0
  } else {
34966
0
    class_name = RT_CONSTANT(opline, opline->op2);
34967
0
try_class_name:
34968
0
    if (Z_TYPE_P(class_name) == IS_OBJECT) {
34969
0
      Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
34970
0
    } else if (Z_TYPE_P(class_name) == IS_STRING) {
34971
0
      Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
34972
0
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
34973
0
      class_name = Z_REFVAL_P(class_name);
34974
0
      goto try_class_name;
34975
0
    } else {
34976
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
34977
0
        ZVAL_UNDEFINED_OP2();
34978
0
        if (UNEXPECTED(EG(exception) != NULL)) {
34979
0
          HANDLE_EXCEPTION();
34980
0
        }
34981
0
      }
34982
0
      zend_throw_error(NULL, "Class name must be a valid object or a string");
34983
0
    }
34984
0
  }
34985
34986
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34987
0
}
34988
34989
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34990
4.92k
{
34991
4.92k
  USE_OPLINE
34992
4.92k
  zval *function_name;
34993
4.92k
  zval *object;
34994
4.92k
  zend_function *fbc;
34995
4.92k
  zend_class_entry *called_scope;
34996
4.92k
  zend_object *obj;
34997
4.92k
  zend_execute_data *call;
34998
4.92k
  uint32_t call_info;
34999
35000
4.92k
  SAVE_OPLINE();
35001
35002
4.92k
  object = &EX(This);
35003
35004
4.92k
  if (IS_CONST != IS_CONST) {
35005
0
    function_name = RT_CONSTANT(opline, opline->op2);
35006
0
  }
35007
35008
4.92k
  if (IS_CONST != IS_CONST &&
35009
4.92k
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
35010
0
    do {
35011
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
35012
0
        function_name = Z_REFVAL_P(function_name);
35013
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
35014
0
          break;
35015
0
        }
35016
0
      } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
35017
0
        ZVAL_UNDEFINED_OP2();
35018
0
        if (UNEXPECTED(EG(exception) != NULL)) {
35019
35020
0
          HANDLE_EXCEPTION();
35021
0
        }
35022
0
      }
35023
0
      zend_throw_error(NULL, "Method name must be a string");
35024
35025
35026
0
      HANDLE_EXCEPTION();
35027
0
    } while (0);
35028
0
  }
35029
35030
4.92k
  if (IS_UNUSED == IS_UNUSED) {
35031
4.92k
    obj = Z_OBJ_P(object);
35032
4.92k
  } else {
35033
0
    do {
35034
0
      if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
35035
0
        obj = Z_OBJ_P(object);
35036
0
      } else {
35037
0
        if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
35038
0
          zend_reference *ref = Z_REF_P(object);
35039
35040
0
          object = &ref->val;
35041
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
35042
0
            obj = Z_OBJ_P(object);
35043
0
            if (IS_UNUSED & IS_VAR) {
35044
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
35045
0
                efree_size(ref, sizeof(zend_reference));
35046
0
              } else {
35047
0
                Z_ADDREF_P(object);
35048
0
              }
35049
0
            }
35050
0
            break;
35051
0
          }
35052
0
        }
35053
0
        if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35054
0
          object = ZVAL_UNDEFINED_OP1();
35055
0
          if (UNEXPECTED(EG(exception) != NULL)) {
35056
0
            if (IS_CONST != IS_CONST) {
35057
35058
0
            }
35059
0
            HANDLE_EXCEPTION();
35060
0
          }
35061
0
        }
35062
0
        if (IS_CONST == IS_CONST) {
35063
0
          function_name = RT_CONSTANT(opline, opline->op2);
35064
0
        }
35065
0
        zend_invalid_method_call(object, function_name);
35066
35067
35068
0
        HANDLE_EXCEPTION();
35069
0
      }
35070
0
    } while (0);
35071
0
  }
35072
35073
4.92k
  called_scope = obj->ce;
35074
35075
4.92k
  if (IS_CONST == IS_CONST &&
35076
4.92k
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
35077
3.90k
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
35078
3.90k
  } else {
35079
1.02k
    zend_object *orig_obj = obj;
35080
35081
1.02k
    if (IS_CONST == IS_CONST) {
35082
1.02k
      function_name = RT_CONSTANT(opline, opline->op2);
35083
1.02k
    }
35084
35085
    /* First, locate the function. */
35086
1.02k
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
35087
1.02k
    if (UNEXPECTED(fbc == NULL)) {
35088
31
      if (EXPECTED(!EG(exception))) {
35089
26
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
35090
26
      }
35091
35092
31
      if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
35093
0
        zend_objects_store_del(orig_obj);
35094
0
      }
35095
31
      HANDLE_EXCEPTION();
35096
31
    }
35097
992
    if (IS_CONST == IS_CONST &&
35098
992
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
35099
992
        EXPECTED(obj == orig_obj)) {
35100
518
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
35101
518
    }
35102
992
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
35103
0
      GC_ADDREF(obj); /* For $this pointer */
35104
0
      if (GC_DELREF(orig_obj) == 0) {
35105
0
        zend_objects_store_del(orig_obj);
35106
0
      }
35107
0
    }
35108
992
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35109
347
      init_func_run_time_cache(&fbc->op_array);
35110
347
    }
35111
992
  }
35112
35113
4.89k
  if (IS_CONST != IS_CONST) {
35114
35115
0
  }
35116
35117
4.89k
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35118
4.89k
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
35119
5
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
35120
0
      zend_objects_store_del(obj);
35121
0
      if (UNEXPECTED(EG(exception))) {
35122
0
        HANDLE_EXCEPTION();
35123
0
      }
35124
0
    }
35125
    /* call static method */
35126
5
    obj = (zend_object*)called_scope;
35127
5
    call_info = ZEND_CALL_NESTED_FUNCTION;
35128
4.89k
  } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
35129
0
    if (IS_UNUSED == IS_CV) {
35130
0
      GC_ADDREF(obj); /* For $this pointer */
35131
0
    }
35132
    /* CV may be changed indirectly (e.g. when it's a reference) */
35133
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
35134
0
  }
35135
35136
4.89k
  call = zend_vm_stack_push_call_frame(call_info,
35137
4.89k
    fbc, opline->extended_value, obj);
35138
4.89k
  call->prev_execute_data = EX(call);
35139
4.89k
  EX(call) = call;
35140
35141
4.89k
  ZEND_VM_NEXT_OPCODE();
35142
4.89k
}
35143
35144
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35145
970
{
35146
970
  USE_OPLINE
35147
970
  zval *function_name;
35148
970
  zend_class_entry *ce;
35149
970
  uint32_t call_info;
35150
970
  zend_function *fbc;
35151
970
  zend_execute_data *call;
35152
35153
970
  SAVE_OPLINE();
35154
35155
970
  if (IS_UNUSED == IS_CONST) {
35156
    /* no function found. try a static method in class */
35157
0
    ce = CACHED_PTR(opline->result.num);
35158
0
    if (UNEXPECTED(ce == NULL)) {
35159
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
35160
0
      if (UNEXPECTED(ce == NULL)) {
35161
35162
0
        HANDLE_EXCEPTION();
35163
0
      }
35164
0
      if (IS_CONST != IS_CONST) {
35165
0
        CACHE_PTR(opline->result.num, ce);
35166
0
      }
35167
0
    }
35168
970
  } else if (IS_UNUSED == IS_UNUSED) {
35169
970
    ce = zend_fetch_class(NULL, opline->op1.num);
35170
970
    if (UNEXPECTED(ce == NULL)) {
35171
35172
5
      HANDLE_EXCEPTION();
35173
5
    }
35174
970
  } else {
35175
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
35176
0
  }
35177
35178
965
  if (IS_UNUSED == IS_CONST &&
35179
965
      IS_CONST == IS_CONST &&
35180
965
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
35181
    /* nothing to do */
35182
965
  } else if (IS_UNUSED != IS_CONST &&
35183
965
             IS_CONST == IS_CONST &&
35184
965
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
35185
402
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
35186
563
  } else if (IS_CONST != IS_UNUSED) {
35187
563
    function_name = RT_CONSTANT(opline, opline->op2);
35188
563
    if (IS_CONST != IS_CONST) {
35189
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
35190
0
        do {
35191
0
          if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
35192
0
            function_name = Z_REFVAL_P(function_name);
35193
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
35194
0
              break;
35195
0
            }
35196
0
          } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
35197
0
            ZVAL_UNDEFINED_OP2();
35198
0
            if (UNEXPECTED(EG(exception) != NULL)) {
35199
0
              HANDLE_EXCEPTION();
35200
0
            }
35201
0
          }
35202
0
          zend_throw_error(NULL, "Method name must be a string");
35203
35204
0
          HANDLE_EXCEPTION();
35205
0
        } while (0);
35206
0
      }
35207
0
    }
35208
35209
563
    if (ce->get_static_method) {
35210
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
35211
563
    } else {
35212
563
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
35213
563
    }
35214
563
    if (UNEXPECTED(fbc == NULL)) {
35215
8
      if (EXPECTED(!EG(exception))) {
35216
8
        zend_undefined_method(ce, Z_STR_P(function_name));
35217
8
      }
35218
35219
8
      HANDLE_EXCEPTION();
35220
8
    }
35221
555
    if (IS_CONST == IS_CONST &&
35222
555
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
35223
555
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
35224
476
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
35225
476
    }
35226
555
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35227
260
      init_func_run_time_cache(&fbc->op_array);
35228
260
    }
35229
555
    if (IS_CONST != IS_CONST) {
35230
35231
0
    }
35232
555
  } else {
35233
0
    if (UNEXPECTED(ce->constructor == NULL)) {
35234
0
      zend_throw_error(NULL, "Cannot call constructor");
35235
0
      HANDLE_EXCEPTION();
35236
0
    }
35237
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
35238
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
35239
0
      HANDLE_EXCEPTION();
35240
0
    }
35241
0
    fbc = ce->constructor;
35242
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35243
0
      init_func_run_time_cache(&fbc->op_array);
35244
0
    }
35245
0
  }
35246
35247
957
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
35248
230
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
35249
230
      ce = (zend_class_entry*)Z_OBJ(EX(This));
35250
230
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35251
230
    } else {
35252
0
      zend_non_static_method_call(fbc);
35253
0
      HANDLE_EXCEPTION();
35254
0
    }
35255
727
  } else {
35256
    /* previous opcode is ZEND_FETCH_CLASS */
35257
727
    if (IS_UNUSED == IS_UNUSED
35258
727
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
35259
727
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
35260
524
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
35261
12
        ce = Z_OBJCE(EX(This));
35262
512
      } else {
35263
512
        ce = Z_CE(EX(This));
35264
512
      }
35265
524
    }
35266
727
    call_info = ZEND_CALL_NESTED_FUNCTION;
35267
727
  }
35268
35269
957
  call = zend_vm_stack_push_call_frame(call_info,
35270
957
    fbc, opline->extended_value, ce);
35271
957
  call->prev_execute_data = EX(call);
35272
957
  EX(call) = call;
35273
35274
957
  ZEND_VM_NEXT_OPCODE();
35275
957
}
35276
35277
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35278
69
{
35279
69
  USE_OPLINE
35280
69
  uint32_t arg_num;
35281
35282
69
  if (IS_CONST == IS_CONST) {
35283
69
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
35284
69
    arg_num = zend_get_arg_offset_by_name(
35285
69
      EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
35286
69
    if (UNEXPECTED(arg_num == 0)) {
35287
      /* Treat this as a by-value argument, and throw an error during SEND. */
35288
0
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35289
0
      ZEND_VM_NEXT_OPCODE();
35290
0
    }
35291
69
  } else {
35292
0
    arg_num = opline->op2.num;
35293
0
  }
35294
35295
69
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
35296
37
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
35297
16
      ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35298
21
    } else {
35299
21
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35300
21
    }
35301
37
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
35302
16
    ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35303
16
  } else {
35304
16
    ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35305
16
  }
35306
69
  ZEND_VM_NEXT_OPCODE();
35307
69
}
35308
35309
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35310
34.0k
{
35311
34.0k
  USE_OPLINE
35312
34.0k
  zend_constant *c;
35313
35314
34.0k
  c = CACHED_PTR(opline->extended_value);
35315
34.0k
  if (EXPECTED(c != NULL) && EXPECTED(!IS_SPECIAL_CACHE_VAL(c))) {
35316
553
    ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
35317
553
    ZEND_VM_NEXT_OPCODE();
35318
553
  }
35319
35320
34.0k
  SAVE_OPLINE();
35321
33.4k
  zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC);
35322
33.4k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35323
33.4k
}
35324
35325
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35326
459
{
35327
459
  zend_class_entry *ce, *scope;
35328
459
  zend_class_constant *c;
35329
459
  zval *value, *zv, *constant_zv;
35330
459
  zend_string *constant_name;
35331
459
  USE_OPLINE
35332
35333
459
  SAVE_OPLINE();
35334
35335
459
  do {
35336
459
    if (IS_UNUSED == IS_CONST && IS_CONST == IS_CONST) {
35337
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
35338
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
35339
0
        break;
35340
0
      }
35341
0
    }
35342
459
    if (IS_UNUSED == IS_CONST) {
35343
0
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
35344
0
        ce = CACHED_PTR(opline->extended_value);
35345
0
      } else {
35346
0
        ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
35347
0
        if (UNEXPECTED(ce == NULL)) {
35348
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35349
35350
0
          HANDLE_EXCEPTION();
35351
0
        }
35352
0
        CACHE_PTR(opline->extended_value, ce);
35353
0
      }
35354
459
    } else if (IS_UNUSED == IS_UNUSED) {
35355
459
      ce = zend_fetch_class(NULL, opline->op1.num);
35356
459
      if (UNEXPECTED(ce == NULL)) {
35357
40
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35358
35359
40
        HANDLE_EXCEPTION();
35360
40
      }
35361
459
    } else {
35362
0
      ce = Z_CE_P(EX_VAR(opline->op1.var));
35363
0
    }
35364
419
    if (IS_UNUSED != IS_CONST
35365
419
      && IS_CONST == IS_CONST
35366
419
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
35367
161
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
35368
161
      break;
35369
161
    }
35370
35371
258
    constant_zv = RT_CONSTANT(opline, opline->op2);
35372
258
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
35373
0
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
35374
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
35375
35376
0
      HANDLE_EXCEPTION();
35377
0
    }
35378
258
    constant_name = Z_STR_P(constant_zv);
35379
    /* Magic 'class' for constant OP2 is caught at compile-time */
35380
258
    if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
35381
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
35382
35383
0
      ZEND_VM_NEXT_OPCODE();
35384
0
    }
35385
258
    zv = IS_CONST == IS_CONST
35386
258
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
35387
258
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
35388
35389
258
    if (EXPECTED(zv != NULL)) {
35390
233
      c = Z_PTR_P(zv);
35391
233
      scope = EX(func)->op_array.scope;
35392
233
      if (!zend_verify_const_access(c, scope)) {
35393
0
        zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35394
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35395
35396
0
        HANDLE_EXCEPTION();
35397
0
      }
35398
35399
233
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
35400
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35401
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35402
35403
0
        HANDLE_EXCEPTION();
35404
0
      }
35405
35406
233
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
35407
233
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
35408
0
        if (c->ce->type == ZEND_USER_CLASS) {
35409
          /* Recursion protection only applied to user constants, GH-18463 */
35410
0
          CONST_PROTECT_RECURSION(c);
35411
0
        }
35412
0
        zend_deprecated_class_constant(c, constant_name);
35413
0
        if (c->ce->type == ZEND_USER_CLASS) {
35414
0
          CONST_UNPROTECT_RECURSION(c);
35415
0
        }
35416
35417
0
        if (EG(exception)) {
35418
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35419
35420
0
          HANDLE_EXCEPTION();
35421
0
        }
35422
0
      }
35423
35424
233
      value = &c->value;
35425
      // Enums require loading of all class constants to build the backed enum table
35426
233
      if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
35427
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
35428
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35429
35430
0
          HANDLE_EXCEPTION();
35431
0
        }
35432
0
      }
35433
233
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
35434
26
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
35435
2
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35436
35437
2
          HANDLE_EXCEPTION();
35438
2
        }
35439
26
      }
35440
231
      if (IS_CONST == IS_CONST && !is_constant_deprecated) {
35441
231
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
35442
231
      }
35443
231
    } else {
35444
25
      zend_throw_error(NULL, "Undefined constant %s::%s",
35445
25
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35446
25
      ZVAL_UNDEF(EX_VAR(opline->result.var));
35447
35448
25
      HANDLE_EXCEPTION();
35449
25
    }
35450
258
  } while (0);
35451
35452
392
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
35453
35454
392
  ZEND_VM_NEXT_OPCODE();
35455
392
}
35456
35457
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35458
0
{
35459
0
  zval *array;
35460
0
  uint32_t size;
35461
0
  USE_OPLINE
35462
35463
0
  SAVE_OPLINE();
35464
0
  array = EX_VAR(opline->result.var);
35465
0
  if (IS_UNUSED != IS_UNUSED) {
35466
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
35467
0
    ZVAL_ARR(array, zend_new_array(size));
35468
    /* Explicitly initialize array as not-packed if flag is set */
35469
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
35470
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
35471
0
    }
35472
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35473
0
  } else {
35474
0
    ZVAL_ARR(array, zend_new_array(0));
35475
0
    ZEND_VM_NEXT_OPCODE();
35476
0
  }
35477
0
}
35478
35479
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35480
1.08k
{
35481
1.08k
  USE_OPLINE
35482
1.08k
  zval *container;
35483
1.08k
  zval *offset;
35484
1.08k
  zend_string *name, *tmp_name;
35485
35486
1.08k
  SAVE_OPLINE();
35487
1.08k
  container = &EX(This);
35488
1.08k
  offset = RT_CONSTANT(opline, opline->op2);
35489
35490
1.08k
  do {
35491
1.08k
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
35492
0
      if (Z_ISREF_P(container)) {
35493
0
        container = Z_REFVAL_P(container);
35494
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
35495
0
          if (IS_UNUSED == IS_CV
35496
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
35497
0
            ZVAL_UNDEFINED_OP1();
35498
0
          }
35499
0
          break;
35500
0
        }
35501
0
      } else {
35502
0
        break;
35503
0
      }
35504
0
    }
35505
1.08k
    if (IS_CONST == IS_CONST) {
35506
1.08k
      name = Z_STR_P(offset);
35507
1.08k
    } else {
35508
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
35509
0
      if (UNEXPECTED(!name)) {
35510
0
        break;
35511
0
      }
35512
0
    }
35513
1.08k
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
35514
1.08k
    if (IS_CONST != IS_CONST) {
35515
0
      zend_tmp_string_release(tmp_name);
35516
0
    }
35517
1.08k
  } while (0);
35518
35519
35520
1.08k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35521
1.08k
}
35522
35523
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35524
76
{
35525
76
  USE_OPLINE
35526
76
  zval *container;
35527
76
  int result;
35528
76
  zval *offset;
35529
76
  zend_string *name, *tmp_name;
35530
35531
76
  SAVE_OPLINE();
35532
76
  container = &EX(This);
35533
76
  offset = RT_CONSTANT(opline, opline->op2);
35534
35535
76
  if (IS_UNUSED == IS_CONST ||
35536
76
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35537
0
    if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35538
0
      container = Z_REFVAL_P(container);
35539
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
35540
0
        result = (opline->extended_value & ZEND_ISEMPTY);
35541
0
        goto isset_object_finish;
35542
0
      }
35543
0
    } else {
35544
0
      result = (opline->extended_value & ZEND_ISEMPTY);
35545
0
      goto isset_object_finish;
35546
0
    }
35547
0
  }
35548
35549
76
  if (IS_CONST == IS_CONST) {
35550
76
    name = Z_STR_P(offset);
35551
76
  } else {
35552
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
35553
0
    if (UNEXPECTED(!name)) {
35554
0
      result = 0;
35555
0
      goto isset_object_finish;
35556
0
    }
35557
0
  }
35558
35559
76
  result =
35560
76
    (opline->extended_value & ZEND_ISEMPTY) ^
35561
76
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
35562
35563
76
  if (IS_CONST != IS_CONST) {
35564
0
    zend_tmp_string_release(tmp_name);
35565
0
  }
35566
35567
76
isset_object_finish:
35568
35569
35570
76
  ZEND_VM_SMART_BRANCH(result, 1);
35571
76
}
35572
35573
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35574
0
{
35575
0
  USE_OPLINE
35576
35577
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
35578
35579
0
  SAVE_OPLINE();
35580
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
35581
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35582
0
  }
35583
35584
  /* Destroy the previously yielded value */
35585
0
  zval_ptr_dtor(&generator->value);
35586
35587
  /* Destroy the previously yielded key */
35588
0
  zval_ptr_dtor(&generator->key);
35589
35590
  /* Set the new yielded value */
35591
0
  if (IS_UNUSED != IS_UNUSED) {
35592
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
35593
      /* Constants and temporary variables aren't yieldable by reference,
35594
       * but we still allow them with a notice. */
35595
0
      if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
35596
0
        zval *value;
35597
35598
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35599
35600
0
        value = NULL;
35601
0
        ZVAL_COPY_VALUE(&generator->value, value);
35602
0
        if (IS_UNUSED == IS_CONST) {
35603
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
35604
0
            Z_ADDREF(generator->value);
35605
0
          }
35606
0
        }
35607
0
      } else {
35608
0
        zval *value_ptr = NULL;
35609
35610
        /* If a function call result is yielded and the function did
35611
         * not return by reference we throw a notice. */
35612
0
        do {
35613
0
          if (IS_UNUSED == IS_VAR) {
35614
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
35615
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
35616
0
             && !Z_ISREF_P(value_ptr)) {
35617
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35618
0
              ZVAL_COPY(&generator->value, value_ptr);
35619
0
              break;
35620
0
            }
35621
0
          }
35622
0
          if (Z_ISREF_P(value_ptr)) {
35623
0
            Z_ADDREF_P(value_ptr);
35624
0
          } else {
35625
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
35626
0
          }
35627
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
35628
0
        } while (0);
35629
35630
0
      }
35631
0
    } else {
35632
0
      zval *value = NULL;
35633
35634
      /* Consts, temporary variables and references need copying */
35635
0
      if (IS_UNUSED == IS_CONST) {
35636
0
        ZVAL_COPY_VALUE(&generator->value, value);
35637
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
35638
0
          Z_ADDREF(generator->value);
35639
0
        }
35640
0
      } else if (IS_UNUSED == IS_TMP_VAR) {
35641
0
        ZVAL_COPY_VALUE(&generator->value, value);
35642
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
35643
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
35644
35645
0
      } else {
35646
0
        ZVAL_COPY_VALUE(&generator->value, value);
35647
0
        if (IS_UNUSED == IS_CV) {
35648
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
35649
0
        }
35650
0
      }
35651
0
    }
35652
0
  } else {
35653
    /* If no value was specified yield null */
35654
0
    ZVAL_NULL(&generator->value);
35655
0
  }
35656
35657
  /* Set the new yielded key */
35658
0
  if (IS_CONST != IS_UNUSED) {
35659
0
    zval *key = RT_CONSTANT(opline, opline->op2);
35660
0
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
35661
0
      key = Z_REFVAL_P(key);
35662
0
    }
35663
0
    ZVAL_COPY(&generator->key, key);
35664
35665
0
    if (Z_TYPE(generator->key) == IS_LONG
35666
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
35667
0
    ) {
35668
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
35669
0
    }
35670
0
  } else {
35671
    /* If no key was specified we use auto-increment keys */
35672
0
    generator->largest_used_integer_key++;
35673
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
35674
0
  }
35675
35676
0
  if (RETURN_VALUE_USED(opline)) {
35677
    /* If the return value of yield is used set the send
35678
     * target and initialize it to NULL */
35679
0
    generator->send_target = EX_VAR(opline->result.var);
35680
0
    ZVAL_NULL(generator->send_target);
35681
0
  } else {
35682
0
    generator->send_target = NULL;
35683
0
  }
35684
35685
  /* The GOTO VM uses a local opline variable. We need to set the opline
35686
   * variable in execute_data so we don't resume at an old position. */
35687
0
  SAVE_OPLINE();
35688
35689
0
  ZEND_VM_RETURN();
35690
0
}
35691
35692
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35693
60
{
35694
60
  zend_class_entry *ce, *scope;
35695
60
  zend_class_constant *c;
35696
60
  zval *value, *zv, *constant_zv;
35697
60
  zend_string *constant_name;
35698
60
  USE_OPLINE
35699
35700
60
  SAVE_OPLINE();
35701
35702
60
  do {
35703
60
    if (IS_UNUSED == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
35704
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
35705
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
35706
0
        break;
35707
0
      }
35708
0
    }
35709
60
    if (IS_UNUSED == IS_CONST) {
35710
0
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
35711
0
        ce = CACHED_PTR(opline->extended_value);
35712
0
      } else {
35713
0
        ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
35714
0
        if (UNEXPECTED(ce == NULL)) {
35715
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35716
0
          FREE_OP(opline->op2_type, opline->op2.var);
35717
0
          HANDLE_EXCEPTION();
35718
0
        }
35719
0
        CACHE_PTR(opline->extended_value, ce);
35720
0
      }
35721
60
    } else if (IS_UNUSED == IS_UNUSED) {
35722
60
      ce = zend_fetch_class(NULL, opline->op1.num);
35723
60
      if (UNEXPECTED(ce == NULL)) {
35724
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35725
0
        FREE_OP(opline->op2_type, opline->op2.var);
35726
0
        HANDLE_EXCEPTION();
35727
0
      }
35728
60
    } else {
35729
0
      ce = Z_CE_P(EX_VAR(opline->op1.var));
35730
0
    }
35731
60
    if (IS_UNUSED != IS_CONST
35732
60
      && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
35733
60
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
35734
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
35735
0
      break;
35736
0
    }
35737
35738
60
    constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
35739
60
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
35740
0
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
35741
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
35742
0
      FREE_OP(opline->op2_type, opline->op2.var);
35743
0
      HANDLE_EXCEPTION();
35744
0
    }
35745
60
    constant_name = Z_STR_P(constant_zv);
35746
    /* Magic 'class' for constant OP2 is caught at compile-time */
35747
60
    if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
35748
30
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
35749
30
      FREE_OP(opline->op2_type, opline->op2.var);
35750
30
      ZEND_VM_NEXT_OPCODE();
35751
30
    }
35752
30
    zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
35753
30
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
35754
30
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
35755
35756
30
    if (EXPECTED(zv != NULL)) {
35757
30
      c = Z_PTR_P(zv);
35758
30
      scope = EX(func)->op_array.scope;
35759
30
      if (!zend_verify_const_access(c, scope)) {
35760
0
        zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35761
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35762
0
        FREE_OP(opline->op2_type, opline->op2.var);
35763
0
        HANDLE_EXCEPTION();
35764
0
      }
35765
35766
30
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
35767
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35768
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35769
0
        FREE_OP(opline->op2_type, opline->op2.var);
35770
0
        HANDLE_EXCEPTION();
35771
0
      }
35772
35773
30
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
35774
30
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
35775
0
        if (c->ce->type == ZEND_USER_CLASS) {
35776
          /* Recursion protection only applied to user constants, GH-18463 */
35777
0
          CONST_PROTECT_RECURSION(c);
35778
0
        }
35779
0
        zend_deprecated_class_constant(c, constant_name);
35780
0
        if (c->ce->type == ZEND_USER_CLASS) {
35781
0
          CONST_UNPROTECT_RECURSION(c);
35782
0
        }
35783
35784
0
        if (EG(exception)) {
35785
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35786
0
          FREE_OP(opline->op2_type, opline->op2.var);
35787
0
          HANDLE_EXCEPTION();
35788
0
        }
35789
0
      }
35790
35791
30
      value = &c->value;
35792
      // Enums require loading of all class constants to build the backed enum table
35793
30
      if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
35794
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
35795
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35796
0
          FREE_OP(opline->op2_type, opline->op2.var);
35797
0
          HANDLE_EXCEPTION();
35798
0
        }
35799
0
      }
35800
30
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
35801
0
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
35802
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35803
0
          FREE_OP(opline->op2_type, opline->op2.var);
35804
0
          HANDLE_EXCEPTION();
35805
0
        }
35806
0
      }
35807
30
      if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
35808
0
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
35809
0
      }
35810
30
    } else {
35811
0
      zend_throw_error(NULL, "Undefined constant %s::%s",
35812
0
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35813
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
35814
0
      FREE_OP(opline->op2_type, opline->op2.var);
35815
0
      HANDLE_EXCEPTION();
35816
0
    }
35817
30
  } while (0);
35818
35819
30
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
35820
35821
30
  FREE_OP(opline->op2_type, opline->op2.var);
35822
30
  ZEND_VM_NEXT_OPCODE();
35823
30
}
35824
35825
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35826
0
{
35827
0
  USE_OPLINE
35828
0
  zval *object;
35829
0
  zval *property;
35830
0
  zval *value;
35831
0
  zval *zptr;
35832
0
  void *_cache_slot[3] = {0};
35833
0
  void **cache_slot;
35834
0
  zend_property_info *prop_info;
35835
0
  zend_object *zobj;
35836
0
  zend_string *name, *tmp_name;
35837
35838
0
  SAVE_OPLINE();
35839
0
  object = &EX(This);
35840
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35841
35842
0
  do {
35843
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
35844
35845
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35846
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35847
0
        object = Z_REFVAL_P(object);
35848
0
        goto assign_op_object;
35849
0
      }
35850
0
      if (IS_UNUSED == IS_CV
35851
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35852
0
        ZVAL_UNDEFINED_OP1();
35853
0
      }
35854
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35855
0
      break;
35856
0
    }
35857
35858
0
assign_op_object:
35859
    /* here we are sure we are dealing with an object */
35860
0
    zobj = Z_OBJ_P(object);
35861
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35862
0
      name = Z_STR_P(property);
35863
0
    } else {
35864
0
      name = zval_try_get_tmp_string(property, &tmp_name);
35865
0
      if (UNEXPECTED(!name)) {
35866
0
        UNDEF_RESULT();
35867
0
        break;
35868
0
      }
35869
0
    }
35870
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
35871
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35872
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35873
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35874
0
          ZVAL_NULL(EX_VAR(opline->result.var));
35875
0
        }
35876
0
      } else {
35877
0
        zend_reference *ref;
35878
35879
0
        do {
35880
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
35881
0
            ref = Z_REF_P(zptr);
35882
0
            zptr = Z_REFVAL_P(zptr);
35883
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
35884
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
35885
0
              break;
35886
0
            }
35887
0
          }
35888
35889
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
35890
0
          if (prop_info) {
35891
            /* special case for typed properties */
35892
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
35893
0
          } else {
35894
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
35895
0
          }
35896
0
        } while (0);
35897
35898
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35899
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
35900
0
        }
35901
0
      }
35902
0
    } else {
35903
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
35904
0
    }
35905
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35906
0
      zend_tmp_string_release(tmp_name);
35907
0
    }
35908
0
  } while (0);
35909
35910
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
35911
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35912
35913
  /* assign_obj has two opcodes! */
35914
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
35915
0
}
35916
35917
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
35918
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35919
0
{
35920
0
  USE_OPLINE
35921
0
  zval *object;
35922
0
  zval *property;
35923
0
  zval *zptr;
35924
0
  void *_cache_slot[3] = {0};
35925
0
  void **cache_slot;
35926
0
  zend_property_info *prop_info;
35927
0
  zend_object *zobj;
35928
0
  zend_string *name, *tmp_name;
35929
35930
0
  SAVE_OPLINE();
35931
0
  object = &EX(This);
35932
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35933
35934
0
  do {
35935
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35936
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35937
0
        object = Z_REFVAL_P(object);
35938
0
        goto pre_incdec_object;
35939
0
      }
35940
0
      if (IS_UNUSED == IS_CV
35941
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35942
0
        ZVAL_UNDEFINED_OP1();
35943
0
      }
35944
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35945
0
      break;
35946
0
    }
35947
35948
0
pre_incdec_object:
35949
    /* here we are sure we are dealing with an object */
35950
0
    zobj = Z_OBJ_P(object);
35951
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35952
0
      name = Z_STR_P(property);
35953
0
    } else {
35954
0
      name = zval_try_get_tmp_string(property, &tmp_name);
35955
0
      if (UNEXPECTED(!name)) {
35956
0
        UNDEF_RESULT();
35957
0
        break;
35958
0
      }
35959
0
    }
35960
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
35961
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35962
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35963
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35964
0
          ZVAL_NULL(EX_VAR(opline->result.var));
35965
0
        }
35966
0
      } else {
35967
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
35968
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35969
0
      }
35970
0
    } else {
35971
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35972
0
    }
35973
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35974
0
      zend_tmp_string_release(tmp_name);
35975
0
    }
35976
0
  } while (0);
35977
35978
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35979
35980
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35981
0
}
35982
35983
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35984
0
{
35985
0
  USE_OPLINE
35986
0
  zval *object;
35987
0
  zval *property;
35988
0
  zval *zptr;
35989
0
  void *_cache_slot[3] = {0};
35990
0
  void **cache_slot;
35991
0
  zend_property_info *prop_info;
35992
0
  zend_object *zobj;
35993
0
  zend_string *name, *tmp_name;
35994
35995
0
  SAVE_OPLINE();
35996
0
  object = &EX(This);
35997
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35998
35999
0
  do {
36000
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36001
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36002
0
        object = Z_REFVAL_P(object);
36003
0
        goto post_incdec_object;
36004
0
      }
36005
0
      if (IS_UNUSED == IS_CV
36006
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
36007
0
        ZVAL_UNDEFINED_OP1();
36008
0
      }
36009
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
36010
0
      break;
36011
0
    }
36012
36013
0
post_incdec_object:
36014
    /* here we are sure we are dealing with an object */
36015
0
    zobj = Z_OBJ_P(object);
36016
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36017
0
      name = Z_STR_P(property);
36018
0
    } else {
36019
0
      name = zval_try_get_tmp_string(property, &tmp_name);
36020
0
      if (UNEXPECTED(!name)) {
36021
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
36022
0
        break;
36023
0
      }
36024
0
    }
36025
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
36026
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
36027
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
36028
0
        ZVAL_NULL(EX_VAR(opline->result.var));
36029
0
      } else {
36030
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
36031
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
36032
0
      }
36033
0
    } else {
36034
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
36035
0
    }
36036
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36037
0
      zend_tmp_string_release(tmp_name);
36038
0
    }
36039
0
  } while (0);
36040
36041
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36042
36043
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36044
0
}
36045
36046
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36047
399
{
36048
399
  USE_OPLINE
36049
399
  zval *container;
36050
399
  void **cache_slot = NULL;
36051
36052
399
  SAVE_OPLINE();
36053
399
  container = &EX(This);
36054
36055
399
  if (IS_UNUSED == IS_CONST ||
36056
399
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
36057
0
    do {
36058
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
36059
0
        container = Z_REFVAL_P(container);
36060
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
36061
0
          break;
36062
0
        }
36063
0
      }
36064
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
36065
0
        ZVAL_UNDEFINED_OP1();
36066
0
      }
36067
0
      zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36068
0
      ZVAL_NULL(EX_VAR(opline->result.var));
36069
0
      goto fetch_obj_r_finish;
36070
0
    } while (0);
36071
0
  }
36072
36073
  /* here we are sure we are dealing with an object */
36074
399
  do {
36075
399
    zend_object *zobj = Z_OBJ_P(container);
36076
399
    zend_string *name, *tmp_name;
36077
399
    zval *retval;
36078
36079
399
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36080
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
36081
36082
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
36083
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36084
36085
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36086
0
fetch_obj_r_simple:
36087
0
          retval = OBJ_PROP(zobj, prop_offset);
36088
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
36089
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36090
0
              goto fetch_obj_r_copy;
36091
0
            } else {
36092
0
fetch_obj_r_fast_copy:
36093
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36094
0
              ZEND_VM_NEXT_OPCODE();
36095
0
            }
36096
0
          }
36097
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
36098
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36099
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
36100
0
            prop_offset = prop_info->offset;
36101
0
            goto fetch_obj_r_simple;
36102
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
36103
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
36104
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
36105
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
36106
36107
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
36108
0
            if (IS_UNUSED & IS_CV) {
36109
0
              GC_ADDREF(zobj);
36110
0
            }
36111
0
            if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
36112
0
              call_info |= ZEND_CALL_RELEASE_THIS;
36113
0
            }
36114
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
36115
0
            call->prev_execute_data = execute_data;
36116
0
            call->call = NULL;
36117
0
            call->return_value = EX_VAR(opline->result.var);
36118
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
36119
36120
0
            execute_data = call;
36121
0
            EG(current_execute_data) = execute_data;
36122
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
36123
36124
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
36125
            opline = hook->op_array.opcodes;
36126
#else
36127
0
            EX(opline) = hook->op_array.opcodes;
36128
0
#endif
36129
0
            LOAD_OPLINE_EX();
36130
36131
36132
0
            ZEND_VM_ENTER_EX();
36133
0
          }
36134
          /* Fall through to read_property for hooks. */
36135
0
        } else if (EXPECTED(zobj->properties != NULL)) {
36136
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
36137
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36138
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
36139
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
36140
36141
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
36142
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
36143
36144
0
              if (EXPECTED(p->key == name) ||
36145
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
36146
0
                   EXPECTED(p->key != NULL) &&
36147
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
36148
0
                retval = &p->val;
36149
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36150
0
                  goto fetch_obj_r_copy;
36151
0
                } else {
36152
0
                  goto fetch_obj_r_fast_copy;
36153
0
                }
36154
0
              }
36155
0
            }
36156
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
36157
0
          }
36158
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
36159
0
          if (EXPECTED(retval)) {
36160
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
36161
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
36162
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36163
0
              goto fetch_obj_r_copy;
36164
0
            } else {
36165
0
              goto fetch_obj_r_fast_copy;
36166
0
            }
36167
0
          }
36168
0
        }
36169
0
      }
36170
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36171
399
    } else {
36172
399
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36173
399
      if (UNEXPECTED(!name)) {
36174
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
36175
0
        break;
36176
0
      }
36177
399
    }
36178
36179
399
#if ZEND_DEBUG
36180
    /* For non-standard object handlers, verify a declared property type in debug builds.
36181
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
36182
399
    zend_property_info *prop_info = NULL;
36183
399
    if (zobj->handlers->read_property != zend_std_read_property) {
36184
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
36185
0
    }
36186
399
#endif
36187
399
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
36188
399
#if ZEND_DEBUG
36189
399
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
36190
399
        && ZEND_TYPE_IS_SET(prop_info->type)) {
36191
0
      ZVAL_OPT_DEREF(retval);
36192
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
36193
0
    }
36194
399
#endif
36195
36196
399
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36197
10
      zend_tmp_string_release(tmp_name);
36198
10
    }
36199
36200
399
    if (retval != EX_VAR(opline->result.var)) {
36201
5
fetch_obj_r_copy:
36202
5
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36203
394
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
36204
0
      zend_unwrap_reference(retval);
36205
0
    }
36206
399
  } while (0);
36207
36208
399
fetch_obj_r_finish:
36209
10
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36210
36211
10
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36212
10
}
36213
36214
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36215
0
{
36216
0
  USE_OPLINE
36217
0
  zval *property, *container, *result;
36218
36219
0
  SAVE_OPLINE();
36220
36221
0
  container = &EX(This);
36222
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36223
0
  result = EX_VAR(opline->result.var);
36224
0
  zend_fetch_property_address(
36225
0
    result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR),
36226
0
    (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
36227
0
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
36228
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36229
0
  if (IS_UNUSED == IS_VAR) {
36230
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36231
0
  }
36232
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36233
0
}
36234
36235
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36236
0
{
36237
0
  USE_OPLINE
36238
0
  zval *property, *container, *result;
36239
36240
0
  SAVE_OPLINE();
36241
0
  container = &EX(This);
36242
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36243
0
  result = EX_VAR(opline->result.var);
36244
0
  zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
36245
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36246
0
  if (IS_UNUSED == IS_VAR) {
36247
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36248
0
  }
36249
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36250
0
}
36251
36252
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36253
0
{
36254
0
  USE_OPLINE
36255
0
  zval *container;
36256
0
  void **cache_slot = NULL;
36257
36258
0
  SAVE_OPLINE();
36259
0
  container = &EX(This);
36260
36261
0
  if (IS_UNUSED == IS_CONST ||
36262
0
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
36263
0
    do {
36264
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
36265
0
        container = Z_REFVAL_P(container);
36266
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
36267
0
          break;
36268
0
        }
36269
0
      }
36270
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
36271
0
        ZVAL_UNDEFINED_OP2();
36272
0
      }
36273
0
      ZVAL_NULL(EX_VAR(opline->result.var));
36274
0
      goto fetch_obj_is_finish;
36275
0
    } while (0);
36276
0
  }
36277
36278
  /* here we are sure we are dealing with an object */
36279
0
  do {
36280
0
    zend_object *zobj = Z_OBJ_P(container);
36281
0
    zend_string *name, *tmp_name;
36282
0
    zval *retval;
36283
36284
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36285
0
      cache_slot = CACHE_ADDR(opline->extended_value);
36286
36287
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
36288
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36289
36290
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36291
0
fetch_obj_is_simple:
36292
0
          retval = OBJ_PROP(zobj, prop_offset);
36293
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
36294
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36295
0
              goto fetch_obj_is_copy;
36296
0
            } else {
36297
0
fetch_obj_is_fast_copy:
36298
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36299
0
              ZEND_VM_NEXT_OPCODE();
36300
0
            }
36301
0
          }
36302
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
36303
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
36304
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36305
0
            prop_offset = prop_info->offset;
36306
0
            goto fetch_obj_is_simple;
36307
0
          }
36308
          /* Fall through to read_property for hooks. */
36309
0
        } else if (EXPECTED(zobj->properties != NULL)) {
36310
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
36311
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36312
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
36313
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
36314
36315
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
36316
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
36317
36318
0
              if (EXPECTED(p->key == name) ||
36319
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
36320
0
                   EXPECTED(p->key != NULL) &&
36321
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
36322
0
                retval = &p->val;
36323
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36324
0
                  goto fetch_obj_is_copy;
36325
0
                } else {
36326
0
                  goto fetch_obj_is_fast_copy;
36327
0
                }
36328
0
              }
36329
0
            }
36330
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
36331
0
          }
36332
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
36333
0
          if (EXPECTED(retval)) {
36334
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
36335
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
36336
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36337
0
              goto fetch_obj_is_copy;
36338
0
            } else {
36339
0
              goto fetch_obj_is_fast_copy;
36340
0
            }
36341
0
          }
36342
0
        }
36343
0
      }
36344
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36345
0
    } else {
36346
0
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36347
0
      if (UNEXPECTED(!name)) {
36348
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
36349
0
        break;
36350
0
      }
36351
0
    }
36352
36353
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
36354
36355
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36356
0
      zend_tmp_string_release(tmp_name);
36357
0
    }
36358
36359
0
    if (retval != EX_VAR(opline->result.var)) {
36360
0
fetch_obj_is_copy:
36361
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36362
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
36363
0
      zend_unwrap_reference(retval);
36364
0
    }
36365
0
  } while (0);
36366
36367
0
fetch_obj_is_finish:
36368
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36369
36370
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36371
0
}
36372
36373
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36374
0
{
36375
#if 0
36376
  USE_OPLINE
36377
#endif
36378
36379
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
36380
    /* Behave like FETCH_OBJ_W */
36381
0
    if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
36382
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36383
0
    }
36384
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36385
0
  } else {
36386
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36387
0
  }
36388
0
}
36389
36390
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36391
0
{
36392
0
  USE_OPLINE
36393
0
  zval *container, *property, *result;
36394
36395
0
  SAVE_OPLINE();
36396
0
  container = &EX(This);
36397
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36398
0
  result = EX_VAR(opline->result.var);
36399
0
  zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
36400
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36401
0
  if (IS_UNUSED == IS_VAR) {
36402
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36403
0
  }
36404
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36405
0
}
36406
36407
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36408
0
{
36409
0
  USE_OPLINE
36410
0
  zval *object, *value, tmp;
36411
0
  zend_object *zobj;
36412
0
  zend_string *name, *tmp_name;
36413
0
  zend_refcounted *garbage = NULL;
36414
36415
0
  SAVE_OPLINE();
36416
0
  object = &EX(This);
36417
0
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
36418
36419
0
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36420
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36421
0
      object = Z_REFVAL_P(object);
36422
0
      goto assign_object;
36423
0
    }
36424
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36425
0
    value = &EG(uninitialized_zval);
36426
0
    goto free_and_exit_assign_obj;
36427
0
  }
36428
36429
0
assign_object:
36430
0
  zobj = Z_OBJ_P(object);
36431
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36432
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36433
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
36434
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36435
0
      zval *property_val;
36436
0
      zend_property_info *prop_info;
36437
36438
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36439
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36440
36441
0
assign_obj_simple:
36442
0
        property_val = OBJ_PROP(zobj, prop_offset);
36443
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
36444
0
          if (prop_info != NULL) {
36445
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36446
0
            goto free_and_exit_assign_obj;
36447
0
          } else {
36448
0
fast_assign_obj:
36449
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
36450
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36451
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
36452
0
            }
36453
0
            goto exit_assign_obj;
36454
0
          }
36455
0
        }
36456
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36457
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36458
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36459
0
          zobj = zend_lazy_object_init(zobj);
36460
0
          if (!zobj) {
36461
0
            value = &EG(uninitialized_zval);
36462
0
            goto free_and_exit_assign_obj;
36463
0
          }
36464
0
        }
36465
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36466
0
          rebuild_object_properties_internal(zobj);
36467
0
        }
36468
0
        if (EXPECTED(zobj->properties != NULL)) {
36469
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36470
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36471
0
              GC_DELREF(zobj->properties);
36472
0
            }
36473
0
            zobj->properties = zend_array_dup(zobj->properties);
36474
0
          }
36475
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
36476
0
          if (property_val) {
36477
0
            goto fast_assign_obj;
36478
0
          }
36479
0
        }
36480
36481
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36482
0
          if (IS_CONST == IS_CONST) {
36483
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36484
0
              Z_ADDREF_P(value);
36485
0
            }
36486
0
          } else if (IS_CONST != IS_TMP_VAR) {
36487
0
            if (Z_ISREF_P(value)) {
36488
0
              if (IS_CONST == IS_VAR) {
36489
0
                zend_reference *ref = Z_REF_P(value);
36490
0
                if (GC_DELREF(ref) == 0) {
36491
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36492
0
                  efree_size(ref, sizeof(zend_reference));
36493
0
                  value = &tmp;
36494
0
                } else {
36495
0
                  value = Z_REFVAL_P(value);
36496
0
                  Z_TRY_ADDREF_P(value);
36497
0
                }
36498
0
              } else {
36499
0
                value = Z_REFVAL_P(value);
36500
0
                Z_TRY_ADDREF_P(value);
36501
0
              }
36502
0
            } else if (IS_CONST == IS_CV) {
36503
0
              Z_TRY_ADDREF_P(value);
36504
0
            }
36505
0
          }
36506
0
          zend_hash_add_new(zobj->properties, name, value);
36507
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36508
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
36509
0
          }
36510
0
          goto exit_assign_obj;
36511
0
        }
36512
0
      } else {
36513
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36514
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36515
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
36516
0
          prop_offset = prop_info->offset;
36517
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36518
0
            prop_info = NULL;
36519
0
          }
36520
0
          goto assign_obj_simple;
36521
0
        }
36522
        /* Fall through to write_property for hooks. */
36523
0
      }
36524
0
    }
36525
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36526
0
  } else {
36527
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36528
0
    if (UNEXPECTED(!name)) {
36529
36530
0
      UNDEF_RESULT();
36531
0
      goto exit_assign_obj;
36532
0
    }
36533
0
  }
36534
36535
0
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
36536
0
    ZVAL_DEREF(value);
36537
0
  }
36538
36539
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36540
36541
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36542
0
    zend_tmp_string_release(tmp_name);
36543
0
  }
36544
36545
0
free_and_exit_assign_obj:
36546
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36547
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36548
0
  }
36549
36550
0
exit_assign_obj:
36551
0
  if (garbage) {
36552
0
    GC_DTOR_NO_REF(garbage);
36553
0
  }
36554
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36555
36556
  /* assign_obj has two opcodes! */
36557
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
36558
0
}
36559
36560
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36561
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36562
2
{
36563
2
  USE_OPLINE
36564
2
  zval *object, *value, tmp;
36565
2
  zend_object *zobj;
36566
2
  zend_string *name, *tmp_name;
36567
2
  zend_refcounted *garbage = NULL;
36568
36569
2
  SAVE_OPLINE();
36570
2
  object = &EX(This);
36571
2
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
36572
36573
2
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36574
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36575
0
      object = Z_REFVAL_P(object);
36576
0
      goto assign_object;
36577
0
    }
36578
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36579
0
    value = &EG(uninitialized_zval);
36580
0
    goto free_and_exit_assign_obj;
36581
0
  }
36582
36583
2
assign_object:
36584
2
  zobj = Z_OBJ_P(object);
36585
2
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36586
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36587
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
36588
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36589
0
      zval *property_val;
36590
0
      zend_property_info *prop_info;
36591
36592
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36593
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36594
36595
0
assign_obj_simple:
36596
0
        property_val = OBJ_PROP(zobj, prop_offset);
36597
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
36598
0
          if (prop_info != NULL) {
36599
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36600
0
            goto free_and_exit_assign_obj;
36601
0
          } else {
36602
0
fast_assign_obj:
36603
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
36604
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36605
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
36606
0
            }
36607
0
            goto exit_assign_obj;
36608
0
          }
36609
0
        }
36610
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36611
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36612
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36613
0
          zobj = zend_lazy_object_init(zobj);
36614
0
          if (!zobj) {
36615
0
            value = &EG(uninitialized_zval);
36616
0
            goto free_and_exit_assign_obj;
36617
0
          }
36618
0
        }
36619
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36620
0
          rebuild_object_properties_internal(zobj);
36621
0
        }
36622
0
        if (EXPECTED(zobj->properties != NULL)) {
36623
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36624
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36625
0
              GC_DELREF(zobj->properties);
36626
0
            }
36627
0
            zobj->properties = zend_array_dup(zobj->properties);
36628
0
          }
36629
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
36630
0
          if (property_val) {
36631
0
            goto fast_assign_obj;
36632
0
          }
36633
0
        }
36634
36635
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36636
0
          if (IS_TMP_VAR == IS_CONST) {
36637
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36638
0
              Z_ADDREF_P(value);
36639
0
            }
36640
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
36641
0
            if (Z_ISREF_P(value)) {
36642
0
              if (IS_TMP_VAR == IS_VAR) {
36643
0
                zend_reference *ref = Z_REF_P(value);
36644
0
                if (GC_DELREF(ref) == 0) {
36645
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36646
0
                  efree_size(ref, sizeof(zend_reference));
36647
0
                  value = &tmp;
36648
0
                } else {
36649
0
                  value = Z_REFVAL_P(value);
36650
0
                  Z_TRY_ADDREF_P(value);
36651
0
                }
36652
0
              } else {
36653
0
                value = Z_REFVAL_P(value);
36654
0
                Z_TRY_ADDREF_P(value);
36655
0
              }
36656
0
            } else if (IS_TMP_VAR == IS_CV) {
36657
0
              Z_TRY_ADDREF_P(value);
36658
0
            }
36659
0
          }
36660
0
          zend_hash_add_new(zobj->properties, name, value);
36661
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36662
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
36663
0
          }
36664
0
          goto exit_assign_obj;
36665
0
        }
36666
0
      } else {
36667
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36668
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36669
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
36670
0
          prop_offset = prop_info->offset;
36671
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36672
0
            prop_info = NULL;
36673
0
          }
36674
0
          goto assign_obj_simple;
36675
0
        }
36676
        /* Fall through to write_property for hooks. */
36677
0
      }
36678
0
    }
36679
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36680
2
  } else {
36681
2
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36682
2
    if (UNEXPECTED(!name)) {
36683
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36684
0
      UNDEF_RESULT();
36685
0
      goto exit_assign_obj;
36686
0
    }
36687
2
  }
36688
36689
2
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
36690
0
    ZVAL_DEREF(value);
36691
0
  }
36692
36693
2
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36694
36695
2
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36696
2
    zend_tmp_string_release(tmp_name);
36697
2
  }
36698
36699
2
free_and_exit_assign_obj:
36700
2
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36701
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36702
0
  }
36703
2
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36704
2
exit_assign_obj:
36705
2
  if (garbage) {
36706
0
    GC_DTOR_NO_REF(garbage);
36707
0
  }
36708
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36709
36710
  /* assign_obj has two opcodes! */
36711
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
36712
2
}
36713
36714
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36715
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36716
0
{
36717
0
  USE_OPLINE
36718
0
  zval *object, *value, tmp;
36719
0
  zend_object *zobj;
36720
0
  zend_string *name, *tmp_name;
36721
0
  zend_refcounted *garbage = NULL;
36722
36723
0
  SAVE_OPLINE();
36724
0
  object = &EX(This);
36725
0
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
36726
36727
0
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36728
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36729
0
      object = Z_REFVAL_P(object);
36730
0
      goto assign_object;
36731
0
    }
36732
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36733
0
    value = &EG(uninitialized_zval);
36734
0
    goto free_and_exit_assign_obj;
36735
0
  }
36736
36737
0
assign_object:
36738
0
  zobj = Z_OBJ_P(object);
36739
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36740
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36741
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
36742
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36743
0
      zval *property_val;
36744
0
      zend_property_info *prop_info;
36745
36746
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36747
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36748
36749
0
assign_obj_simple:
36750
0
        property_val = OBJ_PROP(zobj, prop_offset);
36751
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
36752
0
          if (prop_info != NULL) {
36753
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36754
0
            goto free_and_exit_assign_obj;
36755
0
          } else {
36756
0
fast_assign_obj:
36757
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
36758
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36759
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
36760
0
            }
36761
0
            goto exit_assign_obj;
36762
0
          }
36763
0
        }
36764
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36765
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36766
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36767
0
          zobj = zend_lazy_object_init(zobj);
36768
0
          if (!zobj) {
36769
0
            value = &EG(uninitialized_zval);
36770
0
            goto free_and_exit_assign_obj;
36771
0
          }
36772
0
        }
36773
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36774
0
          rebuild_object_properties_internal(zobj);
36775
0
        }
36776
0
        if (EXPECTED(zobj->properties != NULL)) {
36777
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36778
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36779
0
              GC_DELREF(zobj->properties);
36780
0
            }
36781
0
            zobj->properties = zend_array_dup(zobj->properties);
36782
0
          }
36783
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
36784
0
          if (property_val) {
36785
0
            goto fast_assign_obj;
36786
0
          }
36787
0
        }
36788
36789
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36790
0
          if (IS_VAR == IS_CONST) {
36791
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36792
0
              Z_ADDREF_P(value);
36793
0
            }
36794
0
          } else if (IS_VAR != IS_TMP_VAR) {
36795
0
            if (Z_ISREF_P(value)) {
36796
0
              if (IS_VAR == IS_VAR) {
36797
0
                zend_reference *ref = Z_REF_P(value);
36798
0
                if (GC_DELREF(ref) == 0) {
36799
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36800
0
                  efree_size(ref, sizeof(zend_reference));
36801
0
                  value = &tmp;
36802
0
                } else {
36803
0
                  value = Z_REFVAL_P(value);
36804
0
                  Z_TRY_ADDREF_P(value);
36805
0
                }
36806
0
              } else {
36807
0
                value = Z_REFVAL_P(value);
36808
0
                Z_TRY_ADDREF_P(value);
36809
0
              }
36810
0
            } else if (IS_VAR == IS_CV) {
36811
0
              Z_TRY_ADDREF_P(value);
36812
0
            }
36813
0
          }
36814
0
          zend_hash_add_new(zobj->properties, name, value);
36815
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36816
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
36817
0
          }
36818
0
          goto exit_assign_obj;
36819
0
        }
36820
0
      } else {
36821
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36822
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36823
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
36824
0
          prop_offset = prop_info->offset;
36825
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36826
0
            prop_info = NULL;
36827
0
          }
36828
0
          goto assign_obj_simple;
36829
0
        }
36830
        /* Fall through to write_property for hooks. */
36831
0
      }
36832
0
    }
36833
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36834
0
  } else {
36835
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36836
0
    if (UNEXPECTED(!name)) {
36837
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36838
0
      UNDEF_RESULT();
36839
0
      goto exit_assign_obj;
36840
0
    }
36841
0
  }
36842
36843
0
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
36844
0
    ZVAL_DEREF(value);
36845
0
  }
36846
36847
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36848
36849
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36850
0
    zend_tmp_string_release(tmp_name);
36851
0
  }
36852
36853
0
free_and_exit_assign_obj:
36854
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36855
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36856
0
  }
36857
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36858
0
exit_assign_obj:
36859
0
  if (garbage) {
36860
0
    GC_DTOR_NO_REF(garbage);
36861
0
  }
36862
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36863
36864
  /* assign_obj has two opcodes! */
36865
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
36866
0
}
36867
36868
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36869
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36870
0
{
36871
0
  USE_OPLINE
36872
0
  zval *object, *value, tmp;
36873
0
  zend_object *zobj;
36874
0
  zend_string *name, *tmp_name;
36875
0
  zend_refcounted *garbage = NULL;
36876
36877
0
  SAVE_OPLINE();
36878
0
  object = &EX(This);
36879
0
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
36880
36881
0
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36882
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36883
0
      object = Z_REFVAL_P(object);
36884
0
      goto assign_object;
36885
0
    }
36886
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36887
0
    value = &EG(uninitialized_zval);
36888
0
    goto free_and_exit_assign_obj;
36889
0
  }
36890
36891
0
assign_object:
36892
0
  zobj = Z_OBJ_P(object);
36893
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36894
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36895
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
36896
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36897
0
      zval *property_val;
36898
0
      zend_property_info *prop_info;
36899
36900
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36901
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36902
36903
0
assign_obj_simple:
36904
0
        property_val = OBJ_PROP(zobj, prop_offset);
36905
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
36906
0
          if (prop_info != NULL) {
36907
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36908
0
            goto free_and_exit_assign_obj;
36909
0
          } else {
36910
0
fast_assign_obj:
36911
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
36912
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36913
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
36914
0
            }
36915
0
            goto exit_assign_obj;
36916
0
          }
36917
0
        }
36918
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36919
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36920
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36921
0
          zobj = zend_lazy_object_init(zobj);
36922
0
          if (!zobj) {
36923
0
            value = &EG(uninitialized_zval);
36924
0
            goto free_and_exit_assign_obj;
36925
0
          }
36926
0
        }
36927
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36928
0
          rebuild_object_properties_internal(zobj);
36929
0
        }
36930
0
        if (EXPECTED(zobj->properties != NULL)) {
36931
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36932
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36933
0
              GC_DELREF(zobj->properties);
36934
0
            }
36935
0
            zobj->properties = zend_array_dup(zobj->properties);
36936
0
          }
36937
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
36938
0
          if (property_val) {
36939
0
            goto fast_assign_obj;
36940
0
          }
36941
0
        }
36942
36943
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36944
0
          if (IS_CV == IS_CONST) {
36945
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36946
0
              Z_ADDREF_P(value);
36947
0
            }
36948
0
          } else if (IS_CV != IS_TMP_VAR) {
36949
0
            if (Z_ISREF_P(value)) {
36950
0
              if (IS_CV == IS_VAR) {
36951
0
                zend_reference *ref = Z_REF_P(value);
36952
0
                if (GC_DELREF(ref) == 0) {
36953
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36954
0
                  efree_size(ref, sizeof(zend_reference));
36955
0
                  value = &tmp;
36956
0
                } else {
36957
0
                  value = Z_REFVAL_P(value);
36958
0
                  Z_TRY_ADDREF_P(value);
36959
0
                }
36960
0
              } else {
36961
0
                value = Z_REFVAL_P(value);
36962
0
                Z_TRY_ADDREF_P(value);
36963
0
              }
36964
0
            } else if (IS_CV == IS_CV) {
36965
0
              Z_TRY_ADDREF_P(value);
36966
0
            }
36967
0
          }
36968
0
          zend_hash_add_new(zobj->properties, name, value);
36969
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36970
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
36971
0
          }
36972
0
          goto exit_assign_obj;
36973
0
        }
36974
0
      } else {
36975
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36976
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36977
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
36978
0
          prop_offset = prop_info->offset;
36979
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36980
0
            prop_info = NULL;
36981
0
          }
36982
0
          goto assign_obj_simple;
36983
0
        }
36984
        /* Fall through to write_property for hooks. */
36985
0
      }
36986
0
    }
36987
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36988
0
  } else {
36989
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36990
0
    if (UNEXPECTED(!name)) {
36991
36992
0
      UNDEF_RESULT();
36993
0
      goto exit_assign_obj;
36994
0
    }
36995
0
  }
36996
36997
0
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
36998
0
    ZVAL_DEREF(value);
36999
0
  }
37000
37001
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
37002
37003
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37004
0
    zend_tmp_string_release(tmp_name);
37005
0
  }
37006
37007
0
free_and_exit_assign_obj:
37008
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
37009
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
37010
0
  }
37011
37012
0
exit_assign_obj:
37013
0
  if (garbage) {
37014
0
    GC_DTOR_NO_REF(garbage);
37015
0
  }
37016
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37017
37018
  /* assign_obj has two opcodes! */
37019
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
37020
0
}
37021
37022
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
37023
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37024
0
{
37025
0
  USE_OPLINE
37026
0
  zval *property, *container, *value_ptr;
37027
37028
0
  SAVE_OPLINE();
37029
37030
0
  container = &EX(This);
37031
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37032
37033
0
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
37034
37035
0
  if (1) {
37036
0
    if (IS_UNUSED == IS_UNUSED) {
37037
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37038
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37039
0
      } else {
37040
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37041
0
      }
37042
0
    } else {
37043
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37044
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37045
0
      } else {
37046
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37047
0
      }
37048
0
    }
37049
0
  } else {
37050
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
37051
0
  }
37052
37053
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37054
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
37055
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
37056
0
}
37057
37058
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
37059
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37060
0
{
37061
0
  USE_OPLINE
37062
0
  zval *property, *container, *value_ptr;
37063
37064
0
  SAVE_OPLINE();
37065
37066
0
  container = &EX(This);
37067
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37068
37069
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
37070
37071
0
  if (1) {
37072
0
    if (IS_UNUSED == IS_UNUSED) {
37073
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37074
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37075
0
      } else {
37076
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37077
0
      }
37078
0
    } else {
37079
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37080
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37081
0
      } else {
37082
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37083
0
      }
37084
0
    }
37085
0
  } else {
37086
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
37087
0
  }
37088
37089
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37090
37091
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
37092
0
}
37093
37094
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
37095
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37096
474
{
37097
474
  USE_OPLINE
37098
474
  zend_string **rope;
37099
474
  zval *var;
37100
37101
  /* Compiler allocates the necessary number of zval slots to keep the rope */
37102
474
  rope = (zend_string**)EX_VAR(opline->result.var);
37103
474
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37104
0
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37105
0
    rope[0] = Z_STR_P(var);
37106
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
37107
0
      Z_ADDREF_P(var);
37108
0
    }
37109
474
  } else {
37110
474
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37111
474
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
37112
89
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
37113
0
        rope[0] = zend_string_copy(Z_STR_P(var));
37114
89
      } else {
37115
89
        rope[0] = Z_STR_P(var);
37116
89
      }
37117
385
    } else {
37118
385
      SAVE_OPLINE();
37119
385
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
37120
0
        ZVAL_UNDEFINED_OP2();
37121
0
      }
37122
385
      rope[0] = zval_get_string_func(var);
37123
385
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37124
385
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37125
385
    }
37126
474
  }
37127
89
  ZEND_VM_NEXT_OPCODE();
37128
89
}
37129
37130
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37131
449
{
37132
449
  zval *class_name;
37133
449
  USE_OPLINE
37134
37135
449
  SAVE_OPLINE();
37136
449
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
37137
0
    Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
37138
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37139
449
  } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37140
0
    zend_class_entry *ce = CACHED_PTR(opline->extended_value);
37141
37142
0
    if (UNEXPECTED(ce == NULL)) {
37143
0
      class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37144
0
      ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
37145
0
      CACHE_PTR(opline->extended_value, ce);
37146
0
    }
37147
0
    Z_CE_P(EX_VAR(opline->result.var)) = ce;
37148
449
  } else {
37149
449
    class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37150
449
try_class_name:
37151
449
    if (Z_TYPE_P(class_name) == IS_OBJECT) {
37152
238
      Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
37153
238
    } else if (Z_TYPE_P(class_name) == IS_STRING) {
37154
199
      Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
37155
199
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
37156
0
      class_name = Z_REFVAL_P(class_name);
37157
0
      goto try_class_name;
37158
12
    } else {
37159
12
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
37160
0
        ZVAL_UNDEFINED_OP2();
37161
0
        if (UNEXPECTED(EG(exception) != NULL)) {
37162
0
          HANDLE_EXCEPTION();
37163
0
        }
37164
0
      }
37165
12
      zend_throw_error(NULL, "Class name must be a valid object or a string");
37166
12
    }
37167
449
  }
37168
37169
449
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37170
449
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37171
449
}
37172
37173
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37174
754
{
37175
754
  USE_OPLINE
37176
754
  zval *function_name;
37177
754
  zval *object;
37178
754
  zend_function *fbc;
37179
754
  zend_class_entry *called_scope;
37180
754
  zend_object *obj;
37181
754
  zend_execute_data *call;
37182
754
  uint32_t call_info;
37183
37184
754
  SAVE_OPLINE();
37185
37186
754
  object = &EX(This);
37187
37188
754
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37189
754
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37190
754
  }
37191
37192
754
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
37193
754
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37194
0
    do {
37195
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
37196
0
        function_name = Z_REFVAL_P(function_name);
37197
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37198
0
          break;
37199
0
        }
37200
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37201
0
        ZVAL_UNDEFINED_OP2();
37202
0
        if (UNEXPECTED(EG(exception) != NULL)) {
37203
37204
0
          HANDLE_EXCEPTION();
37205
0
        }
37206
0
      }
37207
0
      zend_throw_error(NULL, "Method name must be a string");
37208
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37209
37210
0
      HANDLE_EXCEPTION();
37211
0
    } while (0);
37212
0
  }
37213
37214
754
  if (IS_UNUSED == IS_UNUSED) {
37215
754
    obj = Z_OBJ_P(object);
37216
754
  } else {
37217
0
    do {
37218
0
      if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
37219
0
        obj = Z_OBJ_P(object);
37220
0
      } else {
37221
0
        if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
37222
0
          zend_reference *ref = Z_REF_P(object);
37223
37224
0
          object = &ref->val;
37225
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
37226
0
            obj = Z_OBJ_P(object);
37227
0
            if (IS_UNUSED & IS_VAR) {
37228
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
37229
0
                efree_size(ref, sizeof(zend_reference));
37230
0
              } else {
37231
0
                Z_ADDREF_P(object);
37232
0
              }
37233
0
            }
37234
0
            break;
37235
0
          }
37236
0
        }
37237
0
        if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37238
0
          object = ZVAL_UNDEFINED_OP1();
37239
0
          if (UNEXPECTED(EG(exception) != NULL)) {
37240
0
            if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37241
0
              zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37242
0
            }
37243
0
            HANDLE_EXCEPTION();
37244
0
          }
37245
0
        }
37246
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37247
0
          function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37248
0
        }
37249
0
        zend_invalid_method_call(object, function_name);
37250
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37251
37252
0
        HANDLE_EXCEPTION();
37253
0
      }
37254
0
    } while (0);
37255
0
  }
37256
37257
754
  called_scope = obj->ce;
37258
37259
754
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37260
754
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
37261
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37262
754
  } else {
37263
754
    zend_object *orig_obj = obj;
37264
37265
754
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37266
0
      function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37267
0
    }
37268
37269
    /* First, locate the function. */
37270
754
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
37271
754
    if (UNEXPECTED(fbc == NULL)) {
37272
0
      if (EXPECTED(!EG(exception))) {
37273
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
37274
0
      }
37275
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37276
0
      if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
37277
0
        zend_objects_store_del(orig_obj);
37278
0
      }
37279
0
      HANDLE_EXCEPTION();
37280
0
    }
37281
754
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37282
754
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37283
754
        EXPECTED(obj == orig_obj)) {
37284
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
37285
0
    }
37286
754
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
37287
0
      GC_ADDREF(obj); /* For $this pointer */
37288
0
      if (GC_DELREF(orig_obj) == 0) {
37289
0
        zend_objects_store_del(orig_obj);
37290
0
      }
37291
0
    }
37292
754
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37293
21
      init_func_run_time_cache(&fbc->op_array);
37294
21
    }
37295
754
  }
37296
37297
754
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37298
754
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37299
754
  }
37300
37301
754
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37302
754
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
37303
0
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
37304
0
      zend_objects_store_del(obj);
37305
0
      if (UNEXPECTED(EG(exception))) {
37306
0
        HANDLE_EXCEPTION();
37307
0
      }
37308
0
    }
37309
    /* call static method */
37310
0
    obj = (zend_object*)called_scope;
37311
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
37312
754
  } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
37313
0
    if (IS_UNUSED == IS_CV) {
37314
0
      GC_ADDREF(obj); /* For $this pointer */
37315
0
    }
37316
    /* CV may be changed indirectly (e.g. when it's a reference) */
37317
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
37318
0
  }
37319
37320
754
  call = zend_vm_stack_push_call_frame(call_info,
37321
754
    fbc, opline->extended_value, obj);
37322
754
  call->prev_execute_data = EX(call);
37323
754
  EX(call) = call;
37324
37325
754
  ZEND_VM_NEXT_OPCODE();
37326
754
}
37327
37328
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37329
5
{
37330
5
  USE_OPLINE
37331
5
  zval *function_name;
37332
5
  zend_class_entry *ce;
37333
5
  uint32_t call_info;
37334
5
  zend_function *fbc;
37335
5
  zend_execute_data *call;
37336
37337
5
  SAVE_OPLINE();
37338
37339
5
  if (IS_UNUSED == IS_CONST) {
37340
    /* no function found. try a static method in class */
37341
0
    ce = CACHED_PTR(opline->result.num);
37342
0
    if (UNEXPECTED(ce == NULL)) {
37343
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
37344
0
      if (UNEXPECTED(ce == NULL)) {
37345
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37346
0
        HANDLE_EXCEPTION();
37347
0
      }
37348
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37349
0
        CACHE_PTR(opline->result.num, ce);
37350
0
      }
37351
0
    }
37352
5
  } else if (IS_UNUSED == IS_UNUSED) {
37353
5
    ce = zend_fetch_class(NULL, opline->op1.num);
37354
5
    if (UNEXPECTED(ce == NULL)) {
37355
5
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37356
5
      HANDLE_EXCEPTION();
37357
5
    }
37358
5
  } else {
37359
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
37360
0
  }
37361
37362
0
  if (IS_UNUSED == IS_CONST &&
37363
0
      (IS_TMP_VAR|IS_VAR) == IS_CONST &&
37364
0
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
37365
    /* nothing to do */
37366
0
  } else if (IS_UNUSED != IS_CONST &&
37367
0
             (IS_TMP_VAR|IS_VAR) == IS_CONST &&
37368
0
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
37369
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37370
0
  } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
37371
0
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37372
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37373
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37374
0
        do {
37375
0
          if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
37376
0
            function_name = Z_REFVAL_P(function_name);
37377
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37378
0
              break;
37379
0
            }
37380
0
          } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37381
0
            ZVAL_UNDEFINED_OP2();
37382
0
            if (UNEXPECTED(EG(exception) != NULL)) {
37383
0
              HANDLE_EXCEPTION();
37384
0
            }
37385
0
          }
37386
0
          zend_throw_error(NULL, "Method name must be a string");
37387
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37388
0
          HANDLE_EXCEPTION();
37389
0
        } while (0);
37390
0
      }
37391
0
    }
37392
37393
0
    if (ce->get_static_method) {
37394
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
37395
0
    } else {
37396
0
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
37397
0
    }
37398
0
    if (UNEXPECTED(fbc == NULL)) {
37399
0
      if (EXPECTED(!EG(exception))) {
37400
0
        zend_undefined_method(ce, Z_STR_P(function_name));
37401
0
      }
37402
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37403
0
      HANDLE_EXCEPTION();
37404
0
    }
37405
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37406
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37407
0
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
37408
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
37409
0
    }
37410
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37411
0
      init_func_run_time_cache(&fbc->op_array);
37412
0
    }
37413
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37414
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37415
0
    }
37416
0
  } else {
37417
0
    if (UNEXPECTED(ce->constructor == NULL)) {
37418
0
      zend_throw_error(NULL, "Cannot call constructor");
37419
0
      HANDLE_EXCEPTION();
37420
0
    }
37421
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
37422
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
37423
0
      HANDLE_EXCEPTION();
37424
0
    }
37425
0
    fbc = ce->constructor;
37426
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37427
0
      init_func_run_time_cache(&fbc->op_array);
37428
0
    }
37429
0
  }
37430
37431
0
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
37432
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
37433
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
37434
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37435
0
    } else {
37436
0
      zend_non_static_method_call(fbc);
37437
0
      HANDLE_EXCEPTION();
37438
0
    }
37439
0
  } else {
37440
    /* previous opcode is ZEND_FETCH_CLASS */
37441
0
    if (IS_UNUSED == IS_UNUSED
37442
0
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
37443
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
37444
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
37445
0
        ce = Z_OBJCE(EX(This));
37446
0
      } else {
37447
0
        ce = Z_CE(EX(This));
37448
0
      }
37449
0
    }
37450
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
37451
0
  }
37452
37453
0
  call = zend_vm_stack_push_call_frame(call_info,
37454
0
    fbc, opline->extended_value, ce);
37455
0
  call->prev_execute_data = EX(call);
37456
0
  EX(call) = call;
37457
37458
0
  ZEND_VM_NEXT_OPCODE();
37459
0
}
37460
37461
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37462
0
{
37463
0
  zval *array;
37464
0
  uint32_t size;
37465
0
  USE_OPLINE
37466
37467
0
  SAVE_OPLINE();
37468
0
  array = EX_VAR(opline->result.var);
37469
0
  if (IS_UNUSED != IS_UNUSED) {
37470
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
37471
0
    ZVAL_ARR(array, zend_new_array(size));
37472
    /* Explicitly initialize array as not-packed if flag is set */
37473
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
37474
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
37475
0
    }
37476
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37477
0
  } else {
37478
0
    ZVAL_ARR(array, zend_new_array(0));
37479
0
    ZEND_VM_NEXT_OPCODE();
37480
0
  }
37481
0
}
37482
37483
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37484
0
{
37485
0
  USE_OPLINE
37486
0
  zval *container;
37487
0
  zval *offset;
37488
0
  zend_string *name, *tmp_name;
37489
37490
0
  SAVE_OPLINE();
37491
0
  container = &EX(This);
37492
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37493
37494
0
  do {
37495
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
37496
0
      if (Z_ISREF_P(container)) {
37497
0
        container = Z_REFVAL_P(container);
37498
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
37499
0
          if (IS_UNUSED == IS_CV
37500
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
37501
0
            ZVAL_UNDEFINED_OP1();
37502
0
          }
37503
0
          break;
37504
0
        }
37505
0
      } else {
37506
0
        break;
37507
0
      }
37508
0
    }
37509
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37510
0
      name = Z_STR_P(offset);
37511
0
    } else {
37512
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
37513
0
      if (UNEXPECTED(!name)) {
37514
0
        break;
37515
0
      }
37516
0
    }
37517
0
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
37518
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37519
0
      zend_tmp_string_release(tmp_name);
37520
0
    }
37521
0
  } while (0);
37522
37523
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37524
37525
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37526
0
}
37527
37528
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37529
0
{
37530
0
  USE_OPLINE
37531
0
  zval *container;
37532
0
  int result;
37533
0
  zval *offset;
37534
0
  zend_string *name, *tmp_name;
37535
37536
0
  SAVE_OPLINE();
37537
0
  container = &EX(This);
37538
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37539
37540
0
  if (IS_UNUSED == IS_CONST ||
37541
0
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
37542
0
    if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
37543
0
      container = Z_REFVAL_P(container);
37544
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
37545
0
        result = (opline->extended_value & ZEND_ISEMPTY);
37546
0
        goto isset_object_finish;
37547
0
      }
37548
0
    } else {
37549
0
      result = (opline->extended_value & ZEND_ISEMPTY);
37550
0
      goto isset_object_finish;
37551
0
    }
37552
0
  }
37553
37554
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37555
0
    name = Z_STR_P(offset);
37556
0
  } else {
37557
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
37558
0
    if (UNEXPECTED(!name)) {
37559
0
      result = 0;
37560
0
      goto isset_object_finish;
37561
0
    }
37562
0
  }
37563
37564
0
  result =
37565
0
    (opline->extended_value & ZEND_ISEMPTY) ^
37566
0
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
37567
37568
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37569
0
    zend_tmp_string_release(tmp_name);
37570
0
  }
37571
37572
0
isset_object_finish:
37573
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37574
37575
0
  ZEND_VM_SMART_BRANCH(result, 1);
37576
0
}
37577
37578
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37579
0
{
37580
0
  USE_OPLINE
37581
37582
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
37583
37584
0
  SAVE_OPLINE();
37585
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
37586
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37587
0
  }
37588
37589
  /* Destroy the previously yielded value */
37590
0
  zval_ptr_dtor(&generator->value);
37591
37592
  /* Destroy the previously yielded key */
37593
0
  zval_ptr_dtor(&generator->key);
37594
37595
  /* Set the new yielded value */
37596
0
  if (IS_UNUSED != IS_UNUSED) {
37597
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37598
      /* Constants and temporary variables aren't yieldable by reference,
37599
       * but we still allow them with a notice. */
37600
0
      if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
37601
0
        zval *value;
37602
37603
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37604
37605
0
        value = NULL;
37606
0
        ZVAL_COPY_VALUE(&generator->value, value);
37607
0
        if (IS_UNUSED == IS_CONST) {
37608
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37609
0
            Z_ADDREF(generator->value);
37610
0
          }
37611
0
        }
37612
0
      } else {
37613
0
        zval *value_ptr = NULL;
37614
37615
        /* If a function call result is yielded and the function did
37616
         * not return by reference we throw a notice. */
37617
0
        do {
37618
0
          if (IS_UNUSED == IS_VAR) {
37619
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
37620
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
37621
0
             && !Z_ISREF_P(value_ptr)) {
37622
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37623
0
              ZVAL_COPY(&generator->value, value_ptr);
37624
0
              break;
37625
0
            }
37626
0
          }
37627
0
          if (Z_ISREF_P(value_ptr)) {
37628
0
            Z_ADDREF_P(value_ptr);
37629
0
          } else {
37630
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
37631
0
          }
37632
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
37633
0
        } while (0);
37634
37635
0
      }
37636
0
    } else {
37637
0
      zval *value = NULL;
37638
37639
      /* Consts, temporary variables and references need copying */
37640
0
      if (IS_UNUSED == IS_CONST) {
37641
0
        ZVAL_COPY_VALUE(&generator->value, value);
37642
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37643
0
          Z_ADDREF(generator->value);
37644
0
        }
37645
0
      } else if (IS_UNUSED == IS_TMP_VAR) {
37646
0
        ZVAL_COPY_VALUE(&generator->value, value);
37647
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
37648
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
37649
37650
0
      } else {
37651
0
        ZVAL_COPY_VALUE(&generator->value, value);
37652
0
        if (IS_UNUSED == IS_CV) {
37653
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
37654
0
        }
37655
0
      }
37656
0
    }
37657
0
  } else {
37658
    /* If no value was specified yield null */
37659
0
    ZVAL_NULL(&generator->value);
37660
0
  }
37661
37662
  /* Set the new yielded key */
37663
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
37664
0
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37665
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
37666
0
      key = Z_REFVAL_P(key);
37667
0
    }
37668
0
    ZVAL_COPY(&generator->key, key);
37669
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37670
37671
0
    if (Z_TYPE(generator->key) == IS_LONG
37672
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
37673
0
    ) {
37674
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
37675
0
    }
37676
0
  } else {
37677
    /* If no key was specified we use auto-increment keys */
37678
0
    generator->largest_used_integer_key++;
37679
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
37680
0
  }
37681
37682
0
  if (RETURN_VALUE_USED(opline)) {
37683
    /* If the return value of yield is used set the send
37684
     * target and initialize it to NULL */
37685
0
    generator->send_target = EX_VAR(opline->result.var);
37686
0
    ZVAL_NULL(generator->send_target);
37687
0
  } else {
37688
0
    generator->send_target = NULL;
37689
0
  }
37690
37691
  /* The GOTO VM uses a local opline variable. We need to set the opline
37692
   * variable in execute_data so we don't resume at an old position. */
37693
0
  SAVE_OPLINE();
37694
37695
0
  ZEND_VM_RETURN();
37696
0
}
37697
37698
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37699
0
{
37700
0
  zval *class_name;
37701
0
  USE_OPLINE
37702
37703
0
  SAVE_OPLINE();
37704
0
  if (IS_UNUSED == IS_UNUSED) {
37705
0
    Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
37706
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37707
0
  } else if (IS_UNUSED == IS_CONST) {
37708
0
    zend_class_entry *ce = CACHED_PTR(opline->extended_value);
37709
37710
0
    if (UNEXPECTED(ce == NULL)) {
37711
0
      class_name = NULL;
37712
0
      ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
37713
0
      CACHE_PTR(opline->extended_value, ce);
37714
0
    }
37715
0
    Z_CE_P(EX_VAR(opline->result.var)) = ce;
37716
0
  } else {
37717
0
    class_name = NULL;
37718
0
try_class_name:
37719
0
    if (Z_TYPE_P(class_name) == IS_OBJECT) {
37720
0
      Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
37721
0
    } else if (Z_TYPE_P(class_name) == IS_STRING) {
37722
0
      Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
37723
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
37724
0
      class_name = Z_REFVAL_P(class_name);
37725
0
      goto try_class_name;
37726
0
    } else {
37727
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
37728
0
        ZVAL_UNDEFINED_OP2();
37729
0
        if (UNEXPECTED(EG(exception) != NULL)) {
37730
0
          HANDLE_EXCEPTION();
37731
0
        }
37732
0
      }
37733
0
      zend_throw_error(NULL, "Class name must be a valid object or a string");
37734
0
    }
37735
0
  }
37736
37737
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37738
0
}
37739
37740
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37741
78
{
37742
78
  USE_OPLINE
37743
78
  zval *function_name;
37744
78
  zend_class_entry *ce;
37745
78
  uint32_t call_info;
37746
78
  zend_function *fbc;
37747
78
  zend_execute_data *call;
37748
37749
78
  SAVE_OPLINE();
37750
37751
78
  if (IS_UNUSED == IS_CONST) {
37752
    /* no function found. try a static method in class */
37753
0
    ce = CACHED_PTR(opline->result.num);
37754
0
    if (UNEXPECTED(ce == NULL)) {
37755
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
37756
0
      if (UNEXPECTED(ce == NULL)) {
37757
37758
0
        HANDLE_EXCEPTION();
37759
0
      }
37760
0
      if (IS_UNUSED != IS_CONST) {
37761
0
        CACHE_PTR(opline->result.num, ce);
37762
0
      }
37763
0
    }
37764
78
  } else if (IS_UNUSED == IS_UNUSED) {
37765
78
    ce = zend_fetch_class(NULL, opline->op1.num);
37766
78
    if (UNEXPECTED(ce == NULL)) {
37767
37768
0
      HANDLE_EXCEPTION();
37769
0
    }
37770
78
  } else {
37771
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
37772
0
  }
37773
37774
78
  if (IS_UNUSED == IS_CONST &&
37775
78
      IS_UNUSED == IS_CONST &&
37776
78
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
37777
    /* nothing to do */
37778
78
  } else if (IS_UNUSED != IS_CONST &&
37779
78
             IS_UNUSED == IS_CONST &&
37780
78
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
37781
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37782
78
  } else if (IS_UNUSED != IS_UNUSED) {
37783
0
    function_name = NULL;
37784
0
    if (IS_UNUSED != IS_CONST) {
37785
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37786
0
        do {
37787
0
          if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
37788
0
            function_name = Z_REFVAL_P(function_name);
37789
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37790
0
              break;
37791
0
            }
37792
0
          } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37793
0
            ZVAL_UNDEFINED_OP2();
37794
0
            if (UNEXPECTED(EG(exception) != NULL)) {
37795
0
              HANDLE_EXCEPTION();
37796
0
            }
37797
0
          }
37798
0
          zend_throw_error(NULL, "Method name must be a string");
37799
37800
0
          HANDLE_EXCEPTION();
37801
0
        } while (0);
37802
0
      }
37803
0
    }
37804
37805
0
    if (ce->get_static_method) {
37806
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
37807
0
    } else {
37808
0
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
37809
0
    }
37810
0
    if (UNEXPECTED(fbc == NULL)) {
37811
0
      if (EXPECTED(!EG(exception))) {
37812
0
        zend_undefined_method(ce, Z_STR_P(function_name));
37813
0
      }
37814
37815
0
      HANDLE_EXCEPTION();
37816
0
    }
37817
0
    if (IS_UNUSED == IS_CONST &&
37818
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37819
0
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
37820
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
37821
0
    }
37822
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37823
0
      init_func_run_time_cache(&fbc->op_array);
37824
0
    }
37825
0
    if (IS_UNUSED != IS_CONST) {
37826
37827
0
    }
37828
78
  } else {
37829
78
    if (UNEXPECTED(ce->constructor == NULL)) {
37830
3
      zend_throw_error(NULL, "Cannot call constructor");
37831
3
      HANDLE_EXCEPTION();
37832
3
    }
37833
75
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
37834
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
37835
0
      HANDLE_EXCEPTION();
37836
0
    }
37837
75
    fbc = ce->constructor;
37838
75
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37839
35
      init_func_run_time_cache(&fbc->op_array);
37840
35
    }
37841
75
  }
37842
37843
75
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
37844
75
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
37845
75
      ce = (zend_class_entry*)Z_OBJ(EX(This));
37846
75
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37847
75
    } else {
37848
0
      zend_non_static_method_call(fbc);
37849
0
      HANDLE_EXCEPTION();
37850
0
    }
37851
75
  } else {
37852
    /* previous opcode is ZEND_FETCH_CLASS */
37853
0
    if (IS_UNUSED == IS_UNUSED
37854
0
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
37855
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
37856
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
37857
0
        ce = Z_OBJCE(EX(This));
37858
0
      } else {
37859
0
        ce = Z_CE(EX(This));
37860
0
      }
37861
0
    }
37862
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
37863
0
  }
37864
37865
75
  call = zend_vm_stack_push_call_frame(call_info,
37866
75
    fbc, opline->extended_value, ce);
37867
75
  call->prev_execute_data = EX(call);
37868
75
  EX(call) = call;
37869
37870
75
  ZEND_VM_NEXT_OPCODE();
37871
75
}
37872
37873
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37874
84
{
37875
84
  if (IS_UNUSED == IS_UNUSED) {
37876
84
    SAVE_OPLINE();
37877
84
    zend_verify_missing_return_type(EX(func));
37878
84
    HANDLE_EXCEPTION();
37879
84
  } else {
37880
/* prevents "undefined variable opline" errors */
37881
#if 0 || (IS_UNUSED != IS_UNUSED)
37882
    USE_OPLINE
37883
    zval *retval_ref, *retval_ptr;
37884
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
37885
    retval_ref = retval_ptr = NULL;
37886
37887
    if (IS_UNUSED == IS_CONST) {
37888
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
37889
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
37890
    } else if (IS_UNUSED == IS_VAR) {
37891
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
37892
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
37893
      }
37894
      ZVAL_DEREF(retval_ptr);
37895
    } else if (IS_UNUSED == IS_CV) {
37896
      ZVAL_DEREF(retval_ptr);
37897
    }
37898
37899
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
37900
      ZEND_VM_NEXT_OPCODE();
37901
    }
37902
37903
    if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
37904
      SAVE_OPLINE();
37905
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
37906
      if (UNEXPECTED(EG(exception))) {
37907
        HANDLE_EXCEPTION();
37908
      }
37909
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
37910
        ZEND_VM_NEXT_OPCODE();
37911
      }
37912
    }
37913
37914
    zend_reference *ref = NULL;
37915
    if (UNEXPECTED(retval_ref != retval_ptr)) {
37916
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37917
        ref = Z_REF_P(retval_ref);
37918
      } else {
37919
        /* A cast might happen - unwrap the reference if this is a by-value return */
37920
        if (Z_REFCOUNT_P(retval_ref) == 1) {
37921
          ZVAL_UNREF(retval_ref);
37922
        } else {
37923
          Z_DELREF_P(retval_ref);
37924
          ZVAL_COPY(retval_ref, retval_ptr);
37925
        }
37926
        retval_ptr = retval_ref;
37927
      }
37928
    }
37929
37930
    SAVE_OPLINE();
37931
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
37932
      zend_verify_return_error(EX(func), retval_ptr);
37933
      HANDLE_EXCEPTION();
37934
    }
37935
    ZEND_VM_NEXT_OPCODE();
37936
#endif
37937
0
  }
37938
84
}
37939
37940
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37941
19
{
37942
19
  SAVE_OPLINE();
37943
19
  zend_verify_never_error(EX(func));
37944
19
  HANDLE_EXCEPTION();
37945
19
}
37946
37947
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37948
0
{
37949
0
  USE_OPLINE
37950
0
  uint32_t arg_num;
37951
37952
0
  if (IS_UNUSED == IS_CONST) {
37953
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
37954
0
    arg_num = zend_get_arg_offset_by_name(
37955
0
      EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
37956
0
    if (UNEXPECTED(arg_num == 0)) {
37957
      /* Treat this as a by-value argument, and throw an error during SEND. */
37958
0
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37959
0
      ZEND_VM_NEXT_OPCODE();
37960
0
    }
37961
0
  } else {
37962
0
    arg_num = opline->op2.num;
37963
0
  }
37964
37965
0
  if (EXPECTED(0)) {
37966
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37967
0
      ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37968
0
    } else {
37969
0
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37970
0
    }
37971
0
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37972
0
    ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37973
0
  } else {
37974
0
    ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37975
0
  }
37976
0
  ZEND_VM_NEXT_OPCODE();
37977
0
}
37978
37979
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37980
1.15k
{
37981
1.15k
  USE_OPLINE
37982
1.15k
  uint32_t arg_num;
37983
37984
1.15k
  if (IS_UNUSED == IS_CONST) {
37985
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
37986
0
    arg_num = zend_get_arg_offset_by_name(
37987
0
      EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
37988
0
    if (UNEXPECTED(arg_num == 0)) {
37989
      /* Treat this as a by-value argument, and throw an error during SEND. */
37990
0
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37991
0
      ZEND_VM_NEXT_OPCODE();
37992
0
    }
37993
1.15k
  } else {
37994
1.15k
    arg_num = opline->op2.num;
37995
1.15k
  }
37996
37997
1.15k
  if (EXPECTED(1)) {
37998
1.15k
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37999
76
      ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
38000
1.07k
    } else {
38001
1.07k
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
38002
1.07k
    }
38003
1.15k
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
38004
0
    ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
38005
0
  } else {
38006
0
    ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
38007
0
  }
38008
1.15k
  ZEND_VM_NEXT_OPCODE();
38009
1.15k
}
38010
38011
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38012
3.34k
{
38013
3.34k
  USE_OPLINE
38014
38015
3.34k
  zend_execute_data *call = execute_data->call;
38016
3.34k
  if (EXPECTED(!(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF))) {
38017
2.71k
    ZEND_VM_NEXT_OPCODE();
38018
2.71k
  }
38019
38020
3.34k
  SAVE_OPLINE();
38021
628
  zend_handle_undef_args(call);
38022
628
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38023
628
}
38024
38025
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38026
374
{
38027
374
  USE_OPLINE
38028
374
  zval *result;
38029
374
  zend_function *constructor;
38030
374
  zend_class_entry *ce;
38031
374
  zend_execute_data *call;
38032
38033
374
  SAVE_OPLINE();
38034
374
  if (IS_UNUSED == IS_CONST) {
38035
0
    ce = CACHED_PTR(opline->op2.num);
38036
0
    if (UNEXPECTED(ce == NULL)) {
38037
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
38038
0
      if (UNEXPECTED(ce == NULL)) {
38039
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38040
0
        HANDLE_EXCEPTION();
38041
0
      }
38042
0
      CACHE_PTR(opline->op2.num, ce);
38043
0
    }
38044
374
  } else if (IS_UNUSED == IS_UNUSED) {
38045
374
    ce = zend_fetch_class(NULL, opline->op1.num);
38046
374
    if (UNEXPECTED(ce == NULL)) {
38047
8
      ZVAL_UNDEF(EX_VAR(opline->result.var));
38048
8
      HANDLE_EXCEPTION();
38049
8
    }
38050
374
  } else {
38051
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
38052
0
  }
38053
38054
366
  result = EX_VAR(opline->result.var);
38055
366
  if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
38056
0
    ZVAL_UNDEF(result);
38057
0
    HANDLE_EXCEPTION();
38058
0
  }
38059
38060
366
  constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
38061
366
  if (constructor == NULL) {
38062
    /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
38063
     * opcode is DO_FCALL in case EXT instructions are used. */
38064
315
    if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
38065
315
      ZEND_VM_NEXT_OPCODE_EX(1, 2);
38066
315
    }
38067
38068
0
    if (UNEXPECTED(EG(exception))) {
38069
0
      HANDLE_EXCEPTION();
38070
0
    }
38071
38072
    /* Perform a dummy function call */
38073
0
    call = zend_vm_stack_push_call_frame(
38074
0
      ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
38075
0
      opline->extended_value, NULL);
38076
51
  } else {
38077
51
    if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
38078
23
      init_func_run_time_cache(&constructor->op_array);
38079
23
    }
38080
    /* We are not handling overloaded classes right now */
38081
51
    call = zend_vm_stack_push_call_frame(
38082
51
      ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
38083
51
      constructor,
38084
51
      opline->extended_value,
38085
51
      Z_OBJ_P(result));
38086
51
    Z_ADDREF_P(result);
38087
51
  }
38088
38089
51
  call->prev_execute_data = EX(call);
38090
51
  EX(call) = call;
38091
51
  ZEND_VM_NEXT_OPCODE();
38092
51
}
38093
38094
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38095
167
{
38096
167
  zval *array;
38097
167
  uint32_t size;
38098
167
  USE_OPLINE
38099
38100
167
  SAVE_OPLINE();
38101
167
  array = EX_VAR(opline->result.var);
38102
167
  if (IS_UNUSED != IS_UNUSED) {
38103
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
38104
0
    ZVAL_ARR(array, zend_new_array(size));
38105
    /* Explicitly initialize array as not-packed if flag is set */
38106
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
38107
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
38108
0
    }
38109
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38110
167
  } else {
38111
167
    ZVAL_ARR(array, zend_new_array(0));
38112
167
    ZEND_VM_NEXT_OPCODE();
38113
167
  }
38114
167
}
38115
38116
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38117
752
{
38118
752
  USE_OPLINE
38119
38120
752
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
38121
38122
752
  SAVE_OPLINE();
38123
752
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
38124
5
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38125
5
  }
38126
38127
  /* Destroy the previously yielded value */
38128
747
  zval_ptr_dtor(&generator->value);
38129
38130
  /* Destroy the previously yielded key */
38131
747
  zval_ptr_dtor(&generator->key);
38132
38133
  /* Set the new yielded value */
38134
747
  if (IS_UNUSED != IS_UNUSED) {
38135
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
38136
      /* Constants and temporary variables aren't yieldable by reference,
38137
       * but we still allow them with a notice. */
38138
0
      if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
38139
0
        zval *value;
38140
38141
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38142
38143
0
        value = NULL;
38144
0
        ZVAL_COPY_VALUE(&generator->value, value);
38145
0
        if (IS_UNUSED == IS_CONST) {
38146
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
38147
0
            Z_ADDREF(generator->value);
38148
0
          }
38149
0
        }
38150
0
      } else {
38151
0
        zval *value_ptr = NULL;
38152
38153
        /* If a function call result is yielded and the function did
38154
         * not return by reference we throw a notice. */
38155
0
        do {
38156
0
          if (IS_UNUSED == IS_VAR) {
38157
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
38158
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
38159
0
             && !Z_ISREF_P(value_ptr)) {
38160
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38161
0
              ZVAL_COPY(&generator->value, value_ptr);
38162
0
              break;
38163
0
            }
38164
0
          }
38165
0
          if (Z_ISREF_P(value_ptr)) {
38166
0
            Z_ADDREF_P(value_ptr);
38167
0
          } else {
38168
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
38169
0
          }
38170
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
38171
0
        } while (0);
38172
38173
0
      }
38174
0
    } else {
38175
0
      zval *value = NULL;
38176
38177
      /* Consts, temporary variables and references need copying */
38178
0
      if (IS_UNUSED == IS_CONST) {
38179
0
        ZVAL_COPY_VALUE(&generator->value, value);
38180
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
38181
0
          Z_ADDREF(generator->value);
38182
0
        }
38183
0
      } else if (IS_UNUSED == IS_TMP_VAR) {
38184
0
        ZVAL_COPY_VALUE(&generator->value, value);
38185
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
38186
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
38187
38188
0
      } else {
38189
0
        ZVAL_COPY_VALUE(&generator->value, value);
38190
0
        if (IS_UNUSED == IS_CV) {
38191
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
38192
0
        }
38193
0
      }
38194
0
    }
38195
747
  } else {
38196
    /* If no value was specified yield null */
38197
747
    ZVAL_NULL(&generator->value);
38198
747
  }
38199
38200
  /* Set the new yielded key */
38201
747
  if (IS_UNUSED != IS_UNUSED) {
38202
0
    zval *key = NULL;
38203
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
38204
0
      key = Z_REFVAL_P(key);
38205
0
    }
38206
0
    ZVAL_COPY(&generator->key, key);
38207
38208
0
    if (Z_TYPE(generator->key) == IS_LONG
38209
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
38210
0
    ) {
38211
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
38212
0
    }
38213
747
  } else {
38214
    /* If no key was specified we use auto-increment keys */
38215
747
    generator->largest_used_integer_key++;
38216
747
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
38217
747
  }
38218
38219
747
  if (RETURN_VALUE_USED(opline)) {
38220
    /* If the return value of yield is used set the send
38221
     * target and initialize it to NULL */
38222
261
    generator->send_target = EX_VAR(opline->result.var);
38223
261
    ZVAL_NULL(generator->send_target);
38224
486
  } else {
38225
486
    generator->send_target = NULL;
38226
486
  }
38227
38228
  /* The GOTO VM uses a local opline variable. We need to set the opline
38229
   * variable in execute_data so we don't resume at an old position. */
38230
747
  SAVE_OPLINE();
38231
38232
747
  ZEND_VM_RETURN();
38233
747
}
38234
38235
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38236
8.76k
{
38237
8.76k
  USE_OPLINE
38238
38239
8.76k
  if (EXPECTED(Z_TYPE(EX(This)) == IS_OBJECT)) {
38240
8.66k
    zval *result = EX_VAR(opline->result.var);
38241
38242
8.66k
    ZVAL_OBJ(result, Z_OBJ(EX(This)));
38243
8.66k
    Z_ADDREF_P(result);
38244
8.66k
    ZEND_VM_NEXT_OPCODE();
38245
8.66k
  } else {
38246
105
    ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38247
105
  }
38248
8.76k
}
38249
38250
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38251
2.41k
{
38252
2.41k
  USE_OPLINE
38253
38254
  /* For symbol tables we need to deal with exactly the same problems as for property tables. */
38255
2.41k
  ZVAL_ARR(EX_VAR(opline->result.var),
38256
2.41k
    zend_proptable_to_symtable(&EG(symbol_table), /* always_duplicate */ 1));
38257
2.41k
  ZEND_VM_NEXT_OPCODE();
38258
2.41k
}
38259
38260
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38261
246
{
38262
246
  USE_OPLINE
38263
38264
246
  ZVAL_BOOL(EX_VAR(opline->result.var),
38265
246
    (opline->extended_value & ZEND_ISEMPTY) ^
38266
246
     (Z_TYPE(EX(This)) == IS_OBJECT));
38267
246
  ZEND_VM_NEXT_OPCODE();
38268
246
}
38269
38270
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38271
39
{
38272
39
  USE_OPLINE
38273
38274
39
  if (IS_UNUSED == IS_UNUSED) {
38275
39
    SAVE_OPLINE();
38276
39
    if (UNEXPECTED(!EX(func)->common.scope)) {
38277
8
      zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
38278
8
      ZVAL_UNDEF(EX_VAR(opline->result.var));
38279
8
      HANDLE_EXCEPTION();
38280
31
    } else {
38281
31
      zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
38282
31
      ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
38283
31
      if (UNEXPECTED(EG(exception))) {
38284
8
        HANDLE_EXCEPTION();
38285
8
      }
38286
23
      ZEND_VM_NEXT_OPCODE();
38287
23
    }
38288
39
  } else {
38289
0
    zval *op1;
38290
38291
0
    SAVE_OPLINE();
38292
0
    op1 = NULL;
38293
0
    while (1) {
38294
0
      if (Z_TYPE_P(op1) == IS_OBJECT) {
38295
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
38296
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
38297
0
        op1 = Z_REFVAL_P(op1);
38298
0
        continue;
38299
0
      } else {
38300
0
        if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
38301
0
          ZVAL_UNDEFINED_OP1();
38302
0
        }
38303
0
        zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
38304
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38305
0
      }
38306
0
      break;
38307
0
    }
38308
38309
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38310
0
  }
38311
39
}
38312
38313
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38314
321
{
38315
321
  USE_OPLINE
38316
38317
321
  if (Z_TYPE(EX(This)) == IS_OBJECT) {
38318
45
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
38319
276
  } else if (Z_CE(EX(This))) {
38320
271
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
38321
271
  } else {
38322
5
    ZEND_ASSERT(!EX(func)->common.scope);
38323
5
    SAVE_OPLINE();
38324
5
    zend_throw_error(NULL, "get_called_class() must be called from within a class");
38325
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
38326
5
    HANDLE_EXCEPTION();
38327
5
  }
38328
316
  ZEND_VM_NEXT_OPCODE();
38329
316
}
38330
38331
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38332
80
{
38333
80
  USE_OPLINE
38334
38335
80
  ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
38336
80
  ZEND_VM_NEXT_OPCODE();
38337
80
}
38338
38339
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38340
157
{
38341
157
  USE_OPLINE
38342
157
  zend_array *ht;
38343
157
  uint32_t arg_count, result_size, skip;
38344
38345
157
  arg_count = EX_NUM_ARGS();
38346
157
  if (IS_UNUSED == IS_CONST) {
38347
0
    skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
38348
0
    if (arg_count < skip) {
38349
0
      result_size = 0;
38350
0
    } else {
38351
0
      result_size = arg_count - skip;
38352
0
    }
38353
157
  } else {
38354
157
    skip = 0;
38355
157
    result_size = arg_count;
38356
157
  }
38357
38358
157
  if (result_size) {
38359
141
    SAVE_OPLINE();
38360
141
    uint32_t first_extra_arg = EX(func)->op_array.num_args;
38361
38362
141
    ht = zend_new_array(result_size);
38363
141
    ZVAL_ARR(EX_VAR(opline->result.var), ht);
38364
141
    zend_hash_real_init_packed(ht);
38365
141
    ZEND_HASH_FILL_PACKED(ht) {
38366
141
      zval *p, *q;
38367
141
      uint32_t i = skip;
38368
141
      p = EX_VAR_NUM(i);
38369
141
      if (arg_count > first_extra_arg) {
38370
257
        while (i < first_extra_arg) {
38371
158
          q = p;
38372
158
          if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
38373
126
            ZVAL_DEREF(q);
38374
126
            if (Z_OPT_REFCOUNTED_P(q)) {
38375
0
              Z_ADDREF_P(q);
38376
0
            }
38377
126
            ZEND_HASH_FILL_SET(q);
38378
126
          } else {
38379
32
            ZEND_HASH_FILL_SET_NULL();
38380
32
          }
38381
158
          ZEND_HASH_FILL_NEXT();
38382
158
          p++;
38383
158
          i++;
38384
158
        }
38385
99
        if (skip < first_extra_arg) {
38386
58
          skip = 0;
38387
58
        } else {
38388
41
          skip -= first_extra_arg;
38389
41
        }
38390
99
        p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
38391
99
      }
38392
332
      while (i < arg_count) {
38393
191
        q = p;
38394
191
        if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
38395
191
          ZVAL_DEREF(q);
38396
191
          if (Z_OPT_REFCOUNTED_P(q)) {
38397
0
            Z_ADDREF_P(q);
38398
0
          }
38399
191
          ZEND_HASH_FILL_SET(q);
38400
191
        } else {
38401
0
          ZEND_HASH_FILL_SET_NULL();
38402
0
        }
38403
191
        ZEND_HASH_FILL_NEXT();
38404
191
        p++;
38405
191
        i++;
38406
191
      }
38407
141
    } ZEND_HASH_FILL_END();
38408
141
    ht->nNumOfElements = result_size;
38409
141
  } else {
38410
16
    ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
38411
16
  }
38412
157
  ZEND_VM_NEXT_OPCODE();
38413
157
}
38414
38415
/* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
38416
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38417
402
{
38418
402
  USE_OPLINE
38419
402
  zend_execute_data *call = EX(call);
38420
38421
402
  zend_closure_from_frame(EX_VAR(opline->result.var), call);
38422
38423
402
  if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
38424
114
    OBJ_RELEASE(Z_OBJ(call->This));
38425
114
  }
38426
38427
402
  EX(call) = call->prev_execute_data;
38428
38429
402
  zend_vm_stack_free_call_frame(call);
38430
38431
402
  ZEND_VM_NEXT_OPCODE();
38432
402
}
38433
38434
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38435
0
{
38436
0
  USE_OPLINE
38437
0
  SAVE_OPLINE();
38438
38439
0
  zval *result = EX_VAR(opline->result.var);
38440
0
  ZVAL_NULL(result);
38441
38442
#if 0 || 0
38443
  if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
38444
    zend_frameless_observed_call(execute_data);
38445
  } else
38446
#endif
38447
0
  {
38448
0
    zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
38449
0
    function(EX_VAR(opline->result.var));
38450
0
  }
38451
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38452
0
}
38453
38454
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38455
0
{
38456
0
  USE_OPLINE
38457
0
  SAVE_OPLINE();
38458
38459
0
  zval *result = EX_VAR(opline->result.var);
38460
0
  ZVAL_NULL(result);
38461
38462
0
#if 0 || 1
38463
0
  if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
38464
0
    zend_frameless_observed_call(execute_data);
38465
0
  } else
38466
0
#endif
38467
0
  {
38468
0
    zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
38469
0
    function(EX_VAR(opline->result.var));
38470
0
  }
38471
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38472
0
}
38473
38474
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38475
23
{
38476
23
  USE_OPLINE
38477
23
  zval *object;
38478
23
  zval *property;
38479
23
  zval *value;
38480
23
  zval *zptr;
38481
23
  void *_cache_slot[3] = {0};
38482
23
  void **cache_slot;
38483
23
  zend_property_info *prop_info;
38484
23
  zend_object *zobj;
38485
23
  zend_string *name, *tmp_name;
38486
38487
23
  SAVE_OPLINE();
38488
23
  object = &EX(This);
38489
23
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38490
38491
23
  do {
38492
23
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
38493
38494
23
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38495
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38496
0
        object = Z_REFVAL_P(object);
38497
0
        goto assign_op_object;
38498
0
      }
38499
0
      if (IS_UNUSED == IS_CV
38500
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38501
0
        ZVAL_UNDEFINED_OP1();
38502
0
      }
38503
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38504
0
      break;
38505
0
    }
38506
38507
23
assign_op_object:
38508
    /* here we are sure we are dealing with an object */
38509
23
    zobj = Z_OBJ_P(object);
38510
23
    if (IS_CV == IS_CONST) {
38511
0
      name = Z_STR_P(property);
38512
23
    } else {
38513
23
      name = zval_try_get_tmp_string(property, &tmp_name);
38514
23
      if (UNEXPECTED(!name)) {
38515
0
        UNDEF_RESULT();
38516
0
        break;
38517
0
      }
38518
23
    }
38519
23
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
38520
23
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38521
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38522
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38523
0
          ZVAL_NULL(EX_VAR(opline->result.var));
38524
0
        }
38525
0
      } else {
38526
0
        zend_reference *ref;
38527
38528
0
        do {
38529
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
38530
0
            ref = Z_REF_P(zptr);
38531
0
            zptr = Z_REFVAL_P(zptr);
38532
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
38533
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
38534
0
              break;
38535
0
            }
38536
0
          }
38537
38538
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
38539
0
          if (prop_info) {
38540
            /* special case for typed properties */
38541
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
38542
0
          } else {
38543
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
38544
0
          }
38545
0
        } while (0);
38546
38547
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38548
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
38549
0
        }
38550
0
      }
38551
23
    } else {
38552
23
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
38553
23
    }
38554
23
    if (IS_CV != IS_CONST) {
38555
23
      zend_tmp_string_release(tmp_name);
38556
23
    }
38557
23
  } while (0);
38558
38559
23
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
38560
38561
38562
  /* assign_obj has two opcodes! */
38563
23
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
38564
23
}
38565
38566
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
38567
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38568
0
{
38569
0
  USE_OPLINE
38570
0
  zval *object;
38571
0
  zval *property;
38572
0
  zval *zptr;
38573
0
  void *_cache_slot[3] = {0};
38574
0
  void **cache_slot;
38575
0
  zend_property_info *prop_info;
38576
0
  zend_object *zobj;
38577
0
  zend_string *name, *tmp_name;
38578
38579
0
  SAVE_OPLINE();
38580
0
  object = &EX(This);
38581
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38582
38583
0
  do {
38584
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38585
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38586
0
        object = Z_REFVAL_P(object);
38587
0
        goto pre_incdec_object;
38588
0
      }
38589
0
      if (IS_UNUSED == IS_CV
38590
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38591
0
        ZVAL_UNDEFINED_OP1();
38592
0
      }
38593
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38594
0
      break;
38595
0
    }
38596
38597
0
pre_incdec_object:
38598
    /* here we are sure we are dealing with an object */
38599
0
    zobj = Z_OBJ_P(object);
38600
0
    if (IS_CV == IS_CONST) {
38601
0
      name = Z_STR_P(property);
38602
0
    } else {
38603
0
      name = zval_try_get_tmp_string(property, &tmp_name);
38604
0
      if (UNEXPECTED(!name)) {
38605
0
        UNDEF_RESULT();
38606
0
        break;
38607
0
      }
38608
0
    }
38609
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
38610
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38611
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38612
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38613
0
          ZVAL_NULL(EX_VAR(opline->result.var));
38614
0
        }
38615
0
      } else {
38616
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
38617
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
38618
0
      }
38619
0
    } else {
38620
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
38621
0
    }
38622
0
    if (IS_CV != IS_CONST) {
38623
0
      zend_tmp_string_release(tmp_name);
38624
0
    }
38625
0
  } while (0);
38626
38627
38628
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38629
0
}
38630
38631
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38632
0
{
38633
0
  USE_OPLINE
38634
0
  zval *object;
38635
0
  zval *property;
38636
0
  zval *zptr;
38637
0
  void *_cache_slot[3] = {0};
38638
0
  void **cache_slot;
38639
0
  zend_property_info *prop_info;
38640
0
  zend_object *zobj;
38641
0
  zend_string *name, *tmp_name;
38642
38643
0
  SAVE_OPLINE();
38644
0
  object = &EX(This);
38645
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38646
38647
0
  do {
38648
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38649
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38650
0
        object = Z_REFVAL_P(object);
38651
0
        goto post_incdec_object;
38652
0
      }
38653
0
      if (IS_UNUSED == IS_CV
38654
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38655
0
        ZVAL_UNDEFINED_OP1();
38656
0
      }
38657
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38658
0
      break;
38659
0
    }
38660
38661
0
post_incdec_object:
38662
    /* here we are sure we are dealing with an object */
38663
0
    zobj = Z_OBJ_P(object);
38664
0
    if (IS_CV == IS_CONST) {
38665
0
      name = Z_STR_P(property);
38666
0
    } else {
38667
0
      name = zval_try_get_tmp_string(property, &tmp_name);
38668
0
      if (UNEXPECTED(!name)) {
38669
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38670
0
        break;
38671
0
      }
38672
0
    }
38673
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
38674
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38675
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38676
0
        ZVAL_NULL(EX_VAR(opline->result.var));
38677
0
      } else {
38678
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
38679
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
38680
0
      }
38681
0
    } else {
38682
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
38683
0
    }
38684
0
    if (IS_CV != IS_CONST) {
38685
0
      zend_tmp_string_release(tmp_name);
38686
0
    }
38687
0
  } while (0);
38688
38689
38690
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38691
0
}
38692
38693
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38694
274
{
38695
274
  USE_OPLINE
38696
274
  zval *container;
38697
274
  void **cache_slot = NULL;
38698
38699
274
  SAVE_OPLINE();
38700
274
  container = &EX(This);
38701
38702
274
  if (IS_UNUSED == IS_CONST ||
38703
274
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38704
0
    do {
38705
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38706
0
        container = Z_REFVAL_P(container);
38707
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
38708
0
          break;
38709
0
        }
38710
0
      }
38711
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
38712
0
        ZVAL_UNDEFINED_OP1();
38713
0
      }
38714
0
      zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38715
0
      ZVAL_NULL(EX_VAR(opline->result.var));
38716
0
      goto fetch_obj_r_finish;
38717
0
    } while (0);
38718
0
  }
38719
38720
  /* here we are sure we are dealing with an object */
38721
274
  do {
38722
274
    zend_object *zobj = Z_OBJ_P(container);
38723
274
    zend_string *name, *tmp_name;
38724
274
    zval *retval;
38725
38726
274
    if (IS_CV == IS_CONST) {
38727
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
38728
38729
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
38730
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38731
38732
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38733
0
fetch_obj_r_simple:
38734
0
          retval = OBJ_PROP(zobj, prop_offset);
38735
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
38736
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38737
0
              goto fetch_obj_r_copy;
38738
0
            } else {
38739
0
fetch_obj_r_fast_copy:
38740
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38741
0
              ZEND_VM_NEXT_OPCODE();
38742
0
            }
38743
0
          }
38744
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
38745
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38746
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
38747
0
            prop_offset = prop_info->offset;
38748
0
            goto fetch_obj_r_simple;
38749
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
38750
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
38751
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
38752
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
38753
38754
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
38755
0
            if (IS_UNUSED & IS_CV) {
38756
0
              GC_ADDREF(zobj);
38757
0
            }
38758
0
            if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
38759
0
              call_info |= ZEND_CALL_RELEASE_THIS;
38760
0
            }
38761
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
38762
0
            call->prev_execute_data = execute_data;
38763
0
            call->call = NULL;
38764
0
            call->return_value = EX_VAR(opline->result.var);
38765
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
38766
38767
0
            execute_data = call;
38768
0
            EG(current_execute_data) = execute_data;
38769
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
38770
38771
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
38772
            opline = hook->op_array.opcodes;
38773
#else
38774
0
            EX(opline) = hook->op_array.opcodes;
38775
0
#endif
38776
0
            LOAD_OPLINE_EX();
38777
38778
38779
0
            ZEND_VM_ENTER_EX();
38780
0
          }
38781
          /* Fall through to read_property for hooks. */
38782
0
        } else if (EXPECTED(zobj->properties != NULL)) {
38783
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
38784
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38785
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
38786
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
38787
38788
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
38789
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
38790
38791
0
              if (EXPECTED(p->key == name) ||
38792
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
38793
0
                   EXPECTED(p->key != NULL) &&
38794
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
38795
0
                retval = &p->val;
38796
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38797
0
                  goto fetch_obj_r_copy;
38798
0
                } else {
38799
0
                  goto fetch_obj_r_fast_copy;
38800
0
                }
38801
0
              }
38802
0
            }
38803
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
38804
0
          }
38805
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
38806
0
          if (EXPECTED(retval)) {
38807
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
38808
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
38809
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38810
0
              goto fetch_obj_r_copy;
38811
0
            } else {
38812
0
              goto fetch_obj_r_fast_copy;
38813
0
            }
38814
0
          }
38815
0
        }
38816
0
      }
38817
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38818
274
    } else {
38819
274
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38820
274
      if (UNEXPECTED(!name)) {
38821
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38822
0
        break;
38823
0
      }
38824
274
    }
38825
38826
274
#if ZEND_DEBUG
38827
    /* For non-standard object handlers, verify a declared property type in debug builds.
38828
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
38829
274
    zend_property_info *prop_info = NULL;
38830
274
    if (zobj->handlers->read_property != zend_std_read_property) {
38831
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
38832
0
    }
38833
274
#endif
38834
274
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
38835
274
#if ZEND_DEBUG
38836
274
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
38837
274
        && ZEND_TYPE_IS_SET(prop_info->type)) {
38838
0
      ZVAL_OPT_DEREF(retval);
38839
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
38840
0
    }
38841
274
#endif
38842
38843
274
    if (IS_CV != IS_CONST) {
38844
273
      zend_tmp_string_release(tmp_name);
38845
273
    }
38846
38847
274
    if (retval != EX_VAR(opline->result.var)) {
38848
256
fetch_obj_r_copy:
38849
256
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38850
256
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
38851
0
      zend_unwrap_reference(retval);
38852
0
    }
38853
274
  } while (0);
38854
38855
274
fetch_obj_r_finish:
38856
38857
38858
273
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38859
273
}
38860
38861
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38862
21
{
38863
21
  USE_OPLINE
38864
21
  zval *property, *container, *result;
38865
38866
21
  SAVE_OPLINE();
38867
38868
21
  container = &EX(This);
38869
21
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38870
21
  result = EX_VAR(opline->result.var);
38871
21
  zend_fetch_property_address(
38872
21
    result, container, IS_UNUSED, property, IS_CV,
38873
21
    ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
38874
21
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
38875
38876
21
  if (IS_UNUSED == IS_VAR) {
38877
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38878
0
  }
38879
21
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38880
21
}
38881
38882
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38883
0
{
38884
0
  USE_OPLINE
38885
0
  zval *property, *container, *result;
38886
38887
0
  SAVE_OPLINE();
38888
0
  container = &EX(This);
38889
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38890
0
  result = EX_VAR(opline->result.var);
38891
0
  zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
38892
38893
0
  if (IS_UNUSED == IS_VAR) {
38894
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38895
0
  }
38896
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38897
0
}
38898
38899
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38900
20
{
38901
20
  USE_OPLINE
38902
20
  zval *container;
38903
20
  void **cache_slot = NULL;
38904
38905
20
  SAVE_OPLINE();
38906
20
  container = &EX(This);
38907
38908
20
  if (IS_UNUSED == IS_CONST ||
38909
20
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38910
0
    do {
38911
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38912
0
        container = Z_REFVAL_P(container);
38913
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
38914
0
          break;
38915
0
        }
38916
0
      }
38917
0
      if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
38918
0
        ZVAL_UNDEFINED_OP2();
38919
0
      }
38920
0
      ZVAL_NULL(EX_VAR(opline->result.var));
38921
0
      goto fetch_obj_is_finish;
38922
0
    } while (0);
38923
0
  }
38924
38925
  /* here we are sure we are dealing with an object */
38926
20
  do {
38927
20
    zend_object *zobj = Z_OBJ_P(container);
38928
20
    zend_string *name, *tmp_name;
38929
20
    zval *retval;
38930
38931
20
    if (IS_CV == IS_CONST) {
38932
0
      cache_slot = CACHE_ADDR(opline->extended_value);
38933
38934
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
38935
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38936
38937
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38938
0
fetch_obj_is_simple:
38939
0
          retval = OBJ_PROP(zobj, prop_offset);
38940
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
38941
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38942
0
              goto fetch_obj_is_copy;
38943
0
            } else {
38944
0
fetch_obj_is_fast_copy:
38945
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38946
0
              ZEND_VM_NEXT_OPCODE();
38947
0
            }
38948
0
          }
38949
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
38950
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
38951
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38952
0
            prop_offset = prop_info->offset;
38953
0
            goto fetch_obj_is_simple;
38954
0
          }
38955
          /* Fall through to read_property for hooks. */
38956
0
        } else if (EXPECTED(zobj->properties != NULL)) {
38957
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
38958
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38959
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
38960
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
38961
38962
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
38963
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
38964
38965
0
              if (EXPECTED(p->key == name) ||
38966
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
38967
0
                   EXPECTED(p->key != NULL) &&
38968
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
38969
0
                retval = &p->val;
38970
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38971
0
                  goto fetch_obj_is_copy;
38972
0
                } else {
38973
0
                  goto fetch_obj_is_fast_copy;
38974
0
                }
38975
0
              }
38976
0
            }
38977
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
38978
0
          }
38979
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
38980
0
          if (EXPECTED(retval)) {
38981
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
38982
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
38983
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38984
0
              goto fetch_obj_is_copy;
38985
0
            } else {
38986
0
              goto fetch_obj_is_fast_copy;
38987
0
            }
38988
0
          }
38989
0
        }
38990
0
      }
38991
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38992
20
    } else {
38993
20
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38994
20
      if (UNEXPECTED(!name)) {
38995
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38996
0
        break;
38997
0
      }
38998
20
    }
38999
39000
20
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
39001
39002
20
    if (IS_CV != IS_CONST) {
39003
20
      zend_tmp_string_release(tmp_name);
39004
20
    }
39005
39006
20
    if (retval != EX_VAR(opline->result.var)) {
39007
15
fetch_obj_is_copy:
39008
15
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
39009
15
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
39010
0
      zend_unwrap_reference(retval);
39011
0
    }
39012
20
  } while (0);
39013
39014
20
fetch_obj_is_finish:
39015
39016
39017
20
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39018
20
}
39019
39020
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39021
0
{
39022
#if 0
39023
  USE_OPLINE
39024
#endif
39025
39026
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
39027
    /* Behave like FETCH_OBJ_W */
39028
0
    if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
39029
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39030
0
    }
39031
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39032
0
  } else {
39033
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39034
0
  }
39035
0
}
39036
39037
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39038
0
{
39039
0
  USE_OPLINE
39040
0
  zval *container, *property, *result;
39041
39042
0
  SAVE_OPLINE();
39043
0
  container = &EX(This);
39044
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39045
0
  result = EX_VAR(opline->result.var);
39046
0
  zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
39047
39048
0
  if (IS_UNUSED == IS_VAR) {
39049
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
39050
0
  }
39051
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39052
0
}
39053
39054
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39055
8
{
39056
8
  USE_OPLINE
39057
8
  zval *object, *value, tmp;
39058
8
  zend_object *zobj;
39059
8
  zend_string *name, *tmp_name;
39060
8
  zend_refcounted *garbage = NULL;
39061
39062
8
  SAVE_OPLINE();
39063
8
  object = &EX(This);
39064
8
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
39065
39066
8
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39067
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39068
0
      object = Z_REFVAL_P(object);
39069
0
      goto assign_object;
39070
0
    }
39071
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39072
0
    value = &EG(uninitialized_zval);
39073
0
    goto free_and_exit_assign_obj;
39074
0
  }
39075
39076
8
assign_object:
39077
8
  zobj = Z_OBJ_P(object);
39078
8
  if (IS_CV == IS_CONST) {
39079
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39080
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
39081
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39082
0
      zval *property_val;
39083
0
      zend_property_info *prop_info;
39084
39085
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39086
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39087
39088
0
assign_obj_simple:
39089
0
        property_val = OBJ_PROP(zobj, prop_offset);
39090
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
39091
0
          if (prop_info != NULL) {
39092
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39093
0
            goto free_and_exit_assign_obj;
39094
0
          } else {
39095
0
fast_assign_obj:
39096
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
39097
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39098
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
39099
0
            }
39100
0
            goto exit_assign_obj;
39101
0
          }
39102
0
        }
39103
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39104
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39105
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39106
0
          zobj = zend_lazy_object_init(zobj);
39107
0
          if (!zobj) {
39108
0
            value = &EG(uninitialized_zval);
39109
0
            goto free_and_exit_assign_obj;
39110
0
          }
39111
0
        }
39112
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39113
0
          rebuild_object_properties_internal(zobj);
39114
0
        }
39115
0
        if (EXPECTED(zobj->properties != NULL)) {
39116
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39117
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39118
0
              GC_DELREF(zobj->properties);
39119
0
            }
39120
0
            zobj->properties = zend_array_dup(zobj->properties);
39121
0
          }
39122
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
39123
0
          if (property_val) {
39124
0
            goto fast_assign_obj;
39125
0
          }
39126
0
        }
39127
39128
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39129
0
          if (IS_CONST == IS_CONST) {
39130
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39131
0
              Z_ADDREF_P(value);
39132
0
            }
39133
0
          } else if (IS_CONST != IS_TMP_VAR) {
39134
0
            if (Z_ISREF_P(value)) {
39135
0
              if (IS_CONST == IS_VAR) {
39136
0
                zend_reference *ref = Z_REF_P(value);
39137
0
                if (GC_DELREF(ref) == 0) {
39138
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39139
0
                  efree_size(ref, sizeof(zend_reference));
39140
0
                  value = &tmp;
39141
0
                } else {
39142
0
                  value = Z_REFVAL_P(value);
39143
0
                  Z_TRY_ADDREF_P(value);
39144
0
                }
39145
0
              } else {
39146
0
                value = Z_REFVAL_P(value);
39147
0
                Z_TRY_ADDREF_P(value);
39148
0
              }
39149
0
            } else if (IS_CONST == IS_CV) {
39150
0
              Z_TRY_ADDREF_P(value);
39151
0
            }
39152
0
          }
39153
0
          zend_hash_add_new(zobj->properties, name, value);
39154
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39155
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
39156
0
          }
39157
0
          goto exit_assign_obj;
39158
0
        }
39159
0
      } else {
39160
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39161
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39162
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
39163
0
          prop_offset = prop_info->offset;
39164
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39165
0
            prop_info = NULL;
39166
0
          }
39167
0
          goto assign_obj_simple;
39168
0
        }
39169
        /* Fall through to write_property for hooks. */
39170
0
      }
39171
0
    }
39172
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39173
8
  } else {
39174
8
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39175
8
    if (UNEXPECTED(!name)) {
39176
39177
0
      UNDEF_RESULT();
39178
0
      goto exit_assign_obj;
39179
0
    }
39180
8
  }
39181
39182
8
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
39183
0
    ZVAL_DEREF(value);
39184
0
  }
39185
39186
8
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39187
39188
8
  if (IS_CV != IS_CONST) {
39189
8
    zend_tmp_string_release(tmp_name);
39190
8
  }
39191
39192
8
free_and_exit_assign_obj:
39193
8
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39194
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39195
0
  }
39196
39197
8
exit_assign_obj:
39198
8
  if (garbage) {
39199
0
    GC_DTOR_NO_REF(garbage);
39200
0
  }
39201
39202
39203
  /* assign_obj has two opcodes! */
39204
8
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39205
8
}
39206
39207
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39208
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39209
20
{
39210
20
  USE_OPLINE
39211
20
  zval *object, *value, tmp;
39212
20
  zend_object *zobj;
39213
20
  zend_string *name, *tmp_name;
39214
20
  zend_refcounted *garbage = NULL;
39215
39216
20
  SAVE_OPLINE();
39217
20
  object = &EX(This);
39218
20
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
39219
39220
20
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39221
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39222
0
      object = Z_REFVAL_P(object);
39223
0
      goto assign_object;
39224
0
    }
39225
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39226
0
    value = &EG(uninitialized_zval);
39227
0
    goto free_and_exit_assign_obj;
39228
0
  }
39229
39230
20
assign_object:
39231
20
  zobj = Z_OBJ_P(object);
39232
20
  if (IS_CV == IS_CONST) {
39233
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39234
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
39235
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39236
0
      zval *property_val;
39237
0
      zend_property_info *prop_info;
39238
39239
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39240
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39241
39242
0
assign_obj_simple:
39243
0
        property_val = OBJ_PROP(zobj, prop_offset);
39244
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
39245
0
          if (prop_info != NULL) {
39246
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39247
0
            goto free_and_exit_assign_obj;
39248
0
          } else {
39249
0
fast_assign_obj:
39250
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
39251
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39252
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
39253
0
            }
39254
0
            goto exit_assign_obj;
39255
0
          }
39256
0
        }
39257
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39258
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39259
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39260
0
          zobj = zend_lazy_object_init(zobj);
39261
0
          if (!zobj) {
39262
0
            value = &EG(uninitialized_zval);
39263
0
            goto free_and_exit_assign_obj;
39264
0
          }
39265
0
        }
39266
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39267
0
          rebuild_object_properties_internal(zobj);
39268
0
        }
39269
0
        if (EXPECTED(zobj->properties != NULL)) {
39270
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39271
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39272
0
              GC_DELREF(zobj->properties);
39273
0
            }
39274
0
            zobj->properties = zend_array_dup(zobj->properties);
39275
0
          }
39276
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
39277
0
          if (property_val) {
39278
0
            goto fast_assign_obj;
39279
0
          }
39280
0
        }
39281
39282
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39283
0
          if (IS_TMP_VAR == IS_CONST) {
39284
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39285
0
              Z_ADDREF_P(value);
39286
0
            }
39287
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
39288
0
            if (Z_ISREF_P(value)) {
39289
0
              if (IS_TMP_VAR == IS_VAR) {
39290
0
                zend_reference *ref = Z_REF_P(value);
39291
0
                if (GC_DELREF(ref) == 0) {
39292
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39293
0
                  efree_size(ref, sizeof(zend_reference));
39294
0
                  value = &tmp;
39295
0
                } else {
39296
0
                  value = Z_REFVAL_P(value);
39297
0
                  Z_TRY_ADDREF_P(value);
39298
0
                }
39299
0
              } else {
39300
0
                value = Z_REFVAL_P(value);
39301
0
                Z_TRY_ADDREF_P(value);
39302
0
              }
39303
0
            } else if (IS_TMP_VAR == IS_CV) {
39304
0
              Z_TRY_ADDREF_P(value);
39305
0
            }
39306
0
          }
39307
0
          zend_hash_add_new(zobj->properties, name, value);
39308
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39309
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
39310
0
          }
39311
0
          goto exit_assign_obj;
39312
0
        }
39313
0
      } else {
39314
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39315
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39316
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
39317
0
          prop_offset = prop_info->offset;
39318
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39319
0
            prop_info = NULL;
39320
0
          }
39321
0
          goto assign_obj_simple;
39322
0
        }
39323
        /* Fall through to write_property for hooks. */
39324
0
      }
39325
0
    }
39326
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39327
20
  } else {
39328
20
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39329
20
    if (UNEXPECTED(!name)) {
39330
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39331
0
      UNDEF_RESULT();
39332
0
      goto exit_assign_obj;
39333
0
    }
39334
20
  }
39335
39336
20
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
39337
0
    ZVAL_DEREF(value);
39338
0
  }
39339
39340
20
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39341
39342
20
  if (IS_CV != IS_CONST) {
39343
20
    zend_tmp_string_release(tmp_name);
39344
20
  }
39345
39346
20
free_and_exit_assign_obj:
39347
20
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39348
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39349
0
  }
39350
20
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39351
20
exit_assign_obj:
39352
20
  if (garbage) {
39353
0
    GC_DTOR_NO_REF(garbage);
39354
0
  }
39355
39356
39357
  /* assign_obj has two opcodes! */
39358
20
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39359
20
}
39360
39361
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39362
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39363
2
{
39364
2
  USE_OPLINE
39365
2
  zval *object, *value, tmp;
39366
2
  zend_object *zobj;
39367
2
  zend_string *name, *tmp_name;
39368
2
  zend_refcounted *garbage = NULL;
39369
39370
2
  SAVE_OPLINE();
39371
2
  object = &EX(This);
39372
2
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
39373
39374
2
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39375
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39376
0
      object = Z_REFVAL_P(object);
39377
0
      goto assign_object;
39378
0
    }
39379
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39380
0
    value = &EG(uninitialized_zval);
39381
0
    goto free_and_exit_assign_obj;
39382
0
  }
39383
39384
2
assign_object:
39385
2
  zobj = Z_OBJ_P(object);
39386
2
  if (IS_CV == IS_CONST) {
39387
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39388
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
39389
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39390
0
      zval *property_val;
39391
0
      zend_property_info *prop_info;
39392
39393
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39394
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39395
39396
0
assign_obj_simple:
39397
0
        property_val = OBJ_PROP(zobj, prop_offset);
39398
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
39399
0
          if (prop_info != NULL) {
39400
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39401
0
            goto free_and_exit_assign_obj;
39402
0
          } else {
39403
0
fast_assign_obj:
39404
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
39405
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39406
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
39407
0
            }
39408
0
            goto exit_assign_obj;
39409
0
          }
39410
0
        }
39411
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39412
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39413
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39414
0
          zobj = zend_lazy_object_init(zobj);
39415
0
          if (!zobj) {
39416
0
            value = &EG(uninitialized_zval);
39417
0
            goto free_and_exit_assign_obj;
39418
0
          }
39419
0
        }
39420
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39421
0
          rebuild_object_properties_internal(zobj);
39422
0
        }
39423
0
        if (EXPECTED(zobj->properties != NULL)) {
39424
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39425
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39426
0
              GC_DELREF(zobj->properties);
39427
0
            }
39428
0
            zobj->properties = zend_array_dup(zobj->properties);
39429
0
          }
39430
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
39431
0
          if (property_val) {
39432
0
            goto fast_assign_obj;
39433
0
          }
39434
0
        }
39435
39436
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39437
0
          if (IS_VAR == IS_CONST) {
39438
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39439
0
              Z_ADDREF_P(value);
39440
0
            }
39441
0
          } else if (IS_VAR != IS_TMP_VAR) {
39442
0
            if (Z_ISREF_P(value)) {
39443
0
              if (IS_VAR == IS_VAR) {
39444
0
                zend_reference *ref = Z_REF_P(value);
39445
0
                if (GC_DELREF(ref) == 0) {
39446
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39447
0
                  efree_size(ref, sizeof(zend_reference));
39448
0
                  value = &tmp;
39449
0
                } else {
39450
0
                  value = Z_REFVAL_P(value);
39451
0
                  Z_TRY_ADDREF_P(value);
39452
0
                }
39453
0
              } else {
39454
0
                value = Z_REFVAL_P(value);
39455
0
                Z_TRY_ADDREF_P(value);
39456
0
              }
39457
0
            } else if (IS_VAR == IS_CV) {
39458
0
              Z_TRY_ADDREF_P(value);
39459
0
            }
39460
0
          }
39461
0
          zend_hash_add_new(zobj->properties, name, value);
39462
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39463
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
39464
0
          }
39465
0
          goto exit_assign_obj;
39466
0
        }
39467
0
      } else {
39468
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39469
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39470
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
39471
0
          prop_offset = prop_info->offset;
39472
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39473
0
            prop_info = NULL;
39474
0
          }
39475
0
          goto assign_obj_simple;
39476
0
        }
39477
        /* Fall through to write_property for hooks. */
39478
0
      }
39479
0
    }
39480
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39481
2
  } else {
39482
2
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39483
2
    if (UNEXPECTED(!name)) {
39484
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39485
0
      UNDEF_RESULT();
39486
0
      goto exit_assign_obj;
39487
0
    }
39488
2
  }
39489
39490
2
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
39491
2
    ZVAL_DEREF(value);
39492
2
  }
39493
39494
2
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39495
39496
2
  if (IS_CV != IS_CONST) {
39497
2
    zend_tmp_string_release(tmp_name);
39498
2
  }
39499
39500
2
free_and_exit_assign_obj:
39501
2
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39502
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39503
0
  }
39504
2
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39505
2
exit_assign_obj:
39506
2
  if (garbage) {
39507
0
    GC_DTOR_NO_REF(garbage);
39508
0
  }
39509
39510
39511
  /* assign_obj has two opcodes! */
39512
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39513
2
}
39514
39515
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39516
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39517
69
{
39518
69
  USE_OPLINE
39519
69
  zval *object, *value, tmp;
39520
69
  zend_object *zobj;
39521
69
  zend_string *name, *tmp_name;
39522
69
  zend_refcounted *garbage = NULL;
39523
39524
69
  SAVE_OPLINE();
39525
69
  object = &EX(This);
39526
69
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
39527
39528
69
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39529
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39530
0
      object = Z_REFVAL_P(object);
39531
0
      goto assign_object;
39532
0
    }
39533
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39534
0
    value = &EG(uninitialized_zval);
39535
0
    goto free_and_exit_assign_obj;
39536
0
  }
39537
39538
69
assign_object:
39539
69
  zobj = Z_OBJ_P(object);
39540
69
  if (IS_CV == IS_CONST) {
39541
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39542
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
39543
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39544
0
      zval *property_val;
39545
0
      zend_property_info *prop_info;
39546
39547
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39548
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39549
39550
0
assign_obj_simple:
39551
0
        property_val = OBJ_PROP(zobj, prop_offset);
39552
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
39553
0
          if (prop_info != NULL) {
39554
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39555
0
            goto free_and_exit_assign_obj;
39556
0
          } else {
39557
0
fast_assign_obj:
39558
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
39559
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39560
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
39561
0
            }
39562
0
            goto exit_assign_obj;
39563
0
          }
39564
0
        }
39565
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39566
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39567
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39568
0
          zobj = zend_lazy_object_init(zobj);
39569
0
          if (!zobj) {
39570
0
            value = &EG(uninitialized_zval);
39571
0
            goto free_and_exit_assign_obj;
39572
0
          }
39573
0
        }
39574
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39575
0
          rebuild_object_properties_internal(zobj);
39576
0
        }
39577
0
        if (EXPECTED(zobj->properties != NULL)) {
39578
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39579
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39580
0
              GC_DELREF(zobj->properties);
39581
0
            }
39582
0
            zobj->properties = zend_array_dup(zobj->properties);
39583
0
          }
39584
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
39585
0
          if (property_val) {
39586
0
            goto fast_assign_obj;
39587
0
          }
39588
0
        }
39589
39590
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39591
0
          if (IS_CV == IS_CONST) {
39592
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39593
0
              Z_ADDREF_P(value);
39594
0
            }
39595
0
          } else if (IS_CV != IS_TMP_VAR) {
39596
0
            if (Z_ISREF_P(value)) {
39597
0
              if (IS_CV == IS_VAR) {
39598
0
                zend_reference *ref = Z_REF_P(value);
39599
0
                if (GC_DELREF(ref) == 0) {
39600
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39601
0
                  efree_size(ref, sizeof(zend_reference));
39602
0
                  value = &tmp;
39603
0
                } else {
39604
0
                  value = Z_REFVAL_P(value);
39605
0
                  Z_TRY_ADDREF_P(value);
39606
0
                }
39607
0
              } else {
39608
0
                value = Z_REFVAL_P(value);
39609
0
                Z_TRY_ADDREF_P(value);
39610
0
              }
39611
0
            } else if (IS_CV == IS_CV) {
39612
0
              Z_TRY_ADDREF_P(value);
39613
0
            }
39614
0
          }
39615
0
          zend_hash_add_new(zobj->properties, name, value);
39616
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39617
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
39618
0
          }
39619
0
          goto exit_assign_obj;
39620
0
        }
39621
0
      } else {
39622
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39623
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39624
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
39625
0
          prop_offset = prop_info->offset;
39626
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39627
0
            prop_info = NULL;
39628
0
          }
39629
0
          goto assign_obj_simple;
39630
0
        }
39631
        /* Fall through to write_property for hooks. */
39632
0
      }
39633
0
    }
39634
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39635
69
  } else {
39636
69
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39637
69
    if (UNEXPECTED(!name)) {
39638
39639
0
      UNDEF_RESULT();
39640
0
      goto exit_assign_obj;
39641
0
    }
39642
69
  }
39643
39644
69
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
39645
69
    ZVAL_DEREF(value);
39646
69
  }
39647
39648
69
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39649
39650
69
  if (IS_CV != IS_CONST) {
39651
69
    zend_tmp_string_release(tmp_name);
39652
69
  }
39653
39654
69
free_and_exit_assign_obj:
39655
69
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39656
2
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39657
2
  }
39658
39659
69
exit_assign_obj:
39660
69
  if (garbage) {
39661
0
    GC_DTOR_NO_REF(garbage);
39662
0
  }
39663
39664
39665
  /* assign_obj has two opcodes! */
39666
69
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39667
69
}
39668
39669
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39670
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39671
2
{
39672
2
  USE_OPLINE
39673
2
  zval *property, *container, *value_ptr;
39674
39675
2
  SAVE_OPLINE();
39676
39677
2
  container = &EX(This);
39678
2
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39679
39680
2
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
39681
39682
2
  if (1) {
39683
2
    if (IS_UNUSED == IS_UNUSED) {
39684
2
      if (IS_CV == IS_CONST) {
39685
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39686
2
      } else {
39687
2
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39688
2
      }
39689
2
    } else {
39690
0
      if (IS_CV == IS_CONST) {
39691
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39692
0
      } else {
39693
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39694
0
      }
39695
0
    }
39696
2
  } else {
39697
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39698
0
  }
39699
39700
39701
2
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39702
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39703
2
}
39704
39705
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39706
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39707
0
{
39708
0
  USE_OPLINE
39709
0
  zval *property, *container, *value_ptr;
39710
39711
0
  SAVE_OPLINE();
39712
39713
0
  container = &EX(This);
39714
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39715
39716
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
39717
39718
0
  if (1) {
39719
0
    if (IS_UNUSED == IS_UNUSED) {
39720
0
      if (IS_CV == IS_CONST) {
39721
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39722
0
      } else {
39723
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39724
0
      }
39725
0
    } else {
39726
0
      if (IS_CV == IS_CONST) {
39727
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39728
0
      } else {
39729
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39730
0
      }
39731
0
    }
39732
0
  } else {
39733
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39734
0
  }
39735
39736
39737
39738
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39739
0
}
39740
39741
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39742
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39743
2.08k
{
39744
2.08k
  USE_OPLINE
39745
2.08k
  zend_string **rope;
39746
2.08k
  zval *var;
39747
39748
  /* Compiler allocates the necessary number of zval slots to keep the rope */
39749
2.08k
  rope = (zend_string**)EX_VAR(opline->result.var);
39750
2.08k
  if (IS_CV == IS_CONST) {
39751
0
    var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39752
0
    rope[0] = Z_STR_P(var);
39753
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
39754
0
      Z_ADDREF_P(var);
39755
0
    }
39756
2.08k
  } else {
39757
2.08k
    var = EX_VAR(opline->op2.var);
39758
2.08k
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
39759
627
      if (IS_CV == IS_CV) {
39760
627
        rope[0] = zend_string_copy(Z_STR_P(var));
39761
627
      } else {
39762
0
        rope[0] = Z_STR_P(var);
39763
0
      }
39764
1.45k
    } else {
39765
1.45k
      SAVE_OPLINE();
39766
1.45k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
39767
583
        ZVAL_UNDEFINED_OP2();
39768
583
      }
39769
1.45k
      rope[0] = zval_get_string_func(var);
39770
39771
1.45k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39772
1.45k
    }
39773
2.08k
  }
39774
627
  ZEND_VM_NEXT_OPCODE();
39775
627
}
39776
39777
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39778
1.40k
{
39779
1.40k
  zval *class_name;
39780
1.40k
  USE_OPLINE
39781
39782
1.40k
  SAVE_OPLINE();
39783
1.40k
  if (IS_CV == IS_UNUSED) {
39784
0
    Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
39785
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39786
1.40k
  } else if (IS_CV == IS_CONST) {
39787
0
    zend_class_entry *ce = CACHED_PTR(opline->extended_value);
39788
39789
0
    if (UNEXPECTED(ce == NULL)) {
39790
0
      class_name = EX_VAR(opline->op2.var);
39791
0
      ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
39792
0
      CACHE_PTR(opline->extended_value, ce);
39793
0
    }
39794
0
    Z_CE_P(EX_VAR(opline->result.var)) = ce;
39795
1.40k
  } else {
39796
1.40k
    class_name = EX_VAR(opline->op2.var);
39797
1.41k
try_class_name:
39798
1.41k
    if (Z_TYPE_P(class_name) == IS_OBJECT) {
39799
121
      Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
39800
1.28k
    } else if (Z_TYPE_P(class_name) == IS_STRING) {
39801
1.24k
      Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
39802
1.24k
    } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
39803
3
      class_name = Z_REFVAL_P(class_name);
39804
3
      goto try_class_name;
39805
45
    } else {
39806
45
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
39807
43
        ZVAL_UNDEFINED_OP2();
39808
43
        if (UNEXPECTED(EG(exception) != NULL)) {
39809
16
          HANDLE_EXCEPTION();
39810
16
        }
39811
43
      }
39812
29
      zend_throw_error(NULL, "Class name must be a valid object or a string");
39813
29
    }
39814
1.41k
  }
39815
39816
1.39k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39817
1.39k
}
39818
39819
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39820
24
{
39821
24
  USE_OPLINE
39822
24
  zval *function_name;
39823
24
  zval *object;
39824
24
  zend_function *fbc;
39825
24
  zend_class_entry *called_scope;
39826
24
  zend_object *obj;
39827
24
  zend_execute_data *call;
39828
24
  uint32_t call_info;
39829
39830
24
  SAVE_OPLINE();
39831
39832
24
  object = &EX(This);
39833
39834
24
  if (IS_CV != IS_CONST) {
39835
24
    function_name = EX_VAR(opline->op2.var);
39836
24
  }
39837
39838
24
  if (IS_CV != IS_CONST &&
39839
24
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
39840
3
    do {
39841
3
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
39842
0
        function_name = Z_REFVAL_P(function_name);
39843
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
39844
0
          break;
39845
0
        }
39846
3
      } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
39847
3
        ZVAL_UNDEFINED_OP2();
39848
3
        if (UNEXPECTED(EG(exception) != NULL)) {
39849
39850
0
          HANDLE_EXCEPTION();
39851
0
        }
39852
3
      }
39853
3
      zend_throw_error(NULL, "Method name must be a string");
39854
39855
39856
3
      HANDLE_EXCEPTION();
39857
3
    } while (0);
39858
3
  }
39859
39860
21
  if (IS_UNUSED == IS_UNUSED) {
39861
21
    obj = Z_OBJ_P(object);
39862
21
  } else {
39863
0
    do {
39864
0
      if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
39865
0
        obj = Z_OBJ_P(object);
39866
0
      } else {
39867
0
        if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
39868
0
          zend_reference *ref = Z_REF_P(object);
39869
39870
0
          object = &ref->val;
39871
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
39872
0
            obj = Z_OBJ_P(object);
39873
0
            if (IS_UNUSED & IS_VAR) {
39874
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
39875
0
                efree_size(ref, sizeof(zend_reference));
39876
0
              } else {
39877
0
                Z_ADDREF_P(object);
39878
0
              }
39879
0
            }
39880
0
            break;
39881
0
          }
39882
0
        }
39883
0
        if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
39884
0
          object = ZVAL_UNDEFINED_OP1();
39885
0
          if (UNEXPECTED(EG(exception) != NULL)) {
39886
0
            if (IS_CV != IS_CONST) {
39887
39888
0
            }
39889
0
            HANDLE_EXCEPTION();
39890
0
          }
39891
0
        }
39892
0
        if (IS_CV == IS_CONST) {
39893
0
          function_name = EX_VAR(opline->op2.var);
39894
0
        }
39895
0
        zend_invalid_method_call(object, function_name);
39896
39897
39898
0
        HANDLE_EXCEPTION();
39899
0
      }
39900
0
    } while (0);
39901
0
  }
39902
39903
21
  called_scope = obj->ce;
39904
39905
21
  if (IS_CV == IS_CONST &&
39906
21
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
39907
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
39908
21
  } else {
39909
21
    zend_object *orig_obj = obj;
39910
39911
21
    if (IS_CV == IS_CONST) {
39912
0
      function_name = EX_VAR(opline->op2.var);
39913
0
    }
39914
39915
    /* First, locate the function. */
39916
21
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
39917
21
    if (UNEXPECTED(fbc == NULL)) {
39918
3
      if (EXPECTED(!EG(exception))) {
39919
3
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
39920
3
      }
39921
39922
3
      if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
39923
0
        zend_objects_store_del(orig_obj);
39924
0
      }
39925
3
      HANDLE_EXCEPTION();
39926
3
    }
39927
18
    if (IS_CV == IS_CONST &&
39928
18
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
39929
18
        EXPECTED(obj == orig_obj)) {
39930
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
39931
0
    }
39932
18
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
39933
0
      GC_ADDREF(obj); /* For $this pointer */
39934
0
      if (GC_DELREF(orig_obj) == 0) {
39935
0
        zend_objects_store_del(orig_obj);
39936
0
      }
39937
0
    }
39938
18
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
39939
5
      init_func_run_time_cache(&fbc->op_array);
39940
5
    }
39941
18
  }
39942
39943
18
  if (IS_CV != IS_CONST) {
39944
39945
18
  }
39946
39947
18
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
39948
18
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
39949
0
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
39950
0
      zend_objects_store_del(obj);
39951
0
      if (UNEXPECTED(EG(exception))) {
39952
0
        HANDLE_EXCEPTION();
39953
0
      }
39954
0
    }
39955
    /* call static method */
39956
0
    obj = (zend_object*)called_scope;
39957
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
39958
18
  } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
39959
0
    if (IS_UNUSED == IS_CV) {
39960
0
      GC_ADDREF(obj); /* For $this pointer */
39961
0
    }
39962
    /* CV may be changed indirectly (e.g. when it's a reference) */
39963
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
39964
0
  }
39965
39966
18
  call = zend_vm_stack_push_call_frame(call_info,
39967
18
    fbc, opline->extended_value, obj);
39968
18
  call->prev_execute_data = EX(call);
39969
18
  EX(call) = call;
39970
39971
18
  ZEND_VM_NEXT_OPCODE();
39972
18
}
39973
39974
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39975
14
{
39976
14
  USE_OPLINE
39977
14
  zval *function_name;
39978
14
  zend_class_entry *ce;
39979
14
  uint32_t call_info;
39980
14
  zend_function *fbc;
39981
14
  zend_execute_data *call;
39982
39983
14
  SAVE_OPLINE();
39984
39985
14
  if (IS_UNUSED == IS_CONST) {
39986
    /* no function found. try a static method in class */
39987
0
    ce = CACHED_PTR(opline->result.num);
39988
0
    if (UNEXPECTED(ce == NULL)) {
39989
0
      ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
39990
0
      if (UNEXPECTED(ce == NULL)) {
39991
39992
0
        HANDLE_EXCEPTION();
39993
0
      }
39994
0
      if (IS_CV != IS_CONST) {
39995
0
        CACHE_PTR(opline->result.num, ce);
39996
0
      }
39997
0
    }
39998
14
  } else if (IS_UNUSED == IS_UNUSED) {
39999
14
    ce = zend_fetch_class(NULL, opline->op1.num);
40000
14
    if (UNEXPECTED(ce == NULL)) {
40001
40002
3
      HANDLE_EXCEPTION();
40003
3
    }
40004
14
  } else {
40005
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
40006
0
  }
40007
40008
11
  if (IS_UNUSED == IS_CONST &&
40009
11
      IS_CV == IS_CONST &&
40010
11
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
40011
    /* nothing to do */
40012
11
  } else if (IS_UNUSED != IS_CONST &&
40013
11
             IS_CV == IS_CONST &&
40014
11
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
40015
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
40016
11
  } else if (IS_CV != IS_UNUSED) {
40017
11
    function_name = EX_VAR(opline->op2.var);
40018
11
    if (IS_CV != IS_CONST) {
40019
11
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
40020
11
        do {
40021
11
          if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
40022
8
            function_name = Z_REFVAL_P(function_name);
40023
8
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
40024
8
              break;
40025
8
            }
40026
8
          } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
40027
3
            ZVAL_UNDEFINED_OP2();
40028
3
            if (UNEXPECTED(EG(exception) != NULL)) {
40029
0
              HANDLE_EXCEPTION();
40030
0
            }
40031
3
          }
40032
3
          zend_throw_error(NULL, "Method name must be a string");
40033
40034
3
          HANDLE_EXCEPTION();
40035
3
        } while (0);
40036
11
      }
40037
11
    }
40038
40039
8
    if (ce->get_static_method) {
40040
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
40041
8
    } else {
40042
8
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
40043
8
    }
40044
8
    if (UNEXPECTED(fbc == NULL)) {
40045
3
      if (EXPECTED(!EG(exception))) {
40046
3
        zend_undefined_method(ce, Z_STR_P(function_name));
40047
3
      }
40048
40049
3
      HANDLE_EXCEPTION();
40050
3
    }
40051
5
    if (IS_CV == IS_CONST &&
40052
5
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
40053
5
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
40054
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
40055
0
    }
40056
5
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
40057
5
      init_func_run_time_cache(&fbc->op_array);
40058
5
    }
40059
5
    if (IS_CV != IS_CONST) {
40060
40061
5
    }
40062
5
  } else {
40063
0
    if (UNEXPECTED(ce->constructor == NULL)) {
40064
0
      zend_throw_error(NULL, "Cannot call constructor");
40065
0
      HANDLE_EXCEPTION();
40066
0
    }
40067
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
40068
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
40069
0
      HANDLE_EXCEPTION();
40070
0
    }
40071
0
    fbc = ce->constructor;
40072
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
40073
0
      init_func_run_time_cache(&fbc->op_array);
40074
0
    }
40075
0
  }
40076
40077
5
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
40078
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
40079
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
40080
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
40081
0
    } else {
40082
0
      zend_non_static_method_call(fbc);
40083
0
      HANDLE_EXCEPTION();
40084
0
    }
40085
5
  } else {
40086
    /* previous opcode is ZEND_FETCH_CLASS */
40087
5
    if (IS_UNUSED == IS_UNUSED
40088
5
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
40089
5
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
40090
5
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
40091
0
        ce = Z_OBJCE(EX(This));
40092
5
      } else {
40093
5
        ce = Z_CE(EX(This));
40094
5
      }
40095
5
    }
40096
5
    call_info = ZEND_CALL_NESTED_FUNCTION;
40097
5
  }
40098
40099
5
  call = zend_vm_stack_push_call_frame(call_info,
40100
5
    fbc, opline->extended_value, ce);
40101
5
  call->prev_execute_data = EX(call);
40102
5
  EX(call) = call;
40103
40104
5
  ZEND_VM_NEXT_OPCODE();
40105
5
}
40106
40107
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40108
0
{
40109
0
  zval *array;
40110
0
  uint32_t size;
40111
0
  USE_OPLINE
40112
40113
0
  SAVE_OPLINE();
40114
0
  array = EX_VAR(opline->result.var);
40115
0
  if (IS_UNUSED != IS_UNUSED) {
40116
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
40117
0
    ZVAL_ARR(array, zend_new_array(size));
40118
    /* Explicitly initialize array as not-packed if flag is set */
40119
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
40120
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
40121
0
    }
40122
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40123
0
  } else {
40124
0
    ZVAL_ARR(array, zend_new_array(0));
40125
0
    ZEND_VM_NEXT_OPCODE();
40126
0
  }
40127
0
}
40128
40129
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40130
25
{
40131
25
  USE_OPLINE
40132
25
  zval *container;
40133
25
  zval *offset;
40134
25
  zend_string *name, *tmp_name;
40135
40136
25
  SAVE_OPLINE();
40137
25
  container = &EX(This);
40138
25
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40139
40140
25
  do {
40141
25
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
40142
0
      if (Z_ISREF_P(container)) {
40143
0
        container = Z_REFVAL_P(container);
40144
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
40145
0
          if (IS_UNUSED == IS_CV
40146
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
40147
0
            ZVAL_UNDEFINED_OP1();
40148
0
          }
40149
0
          break;
40150
0
        }
40151
0
      } else {
40152
0
        break;
40153
0
      }
40154
0
    }
40155
25
    if (IS_CV == IS_CONST) {
40156
0
      name = Z_STR_P(offset);
40157
25
    } else {
40158
25
      name = zval_try_get_tmp_string(offset, &tmp_name);
40159
25
      if (UNEXPECTED(!name)) {
40160
0
        break;
40161
0
      }
40162
25
    }
40163
25
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
40164
25
    if (IS_CV != IS_CONST) {
40165
25
      zend_tmp_string_release(tmp_name);
40166
25
    }
40167
25
  } while (0);
40168
40169
40170
25
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40171
25
}
40172
40173
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40174
43
{
40175
43
  USE_OPLINE
40176
43
  zval *container;
40177
43
  int result;
40178
43
  zval *offset;
40179
43
  zend_string *name, *tmp_name;
40180
40181
43
  SAVE_OPLINE();
40182
43
  container = &EX(This);
40183
43
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40184
40185
43
  if (IS_UNUSED == IS_CONST ||
40186
43
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
40187
0
    if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
40188
0
      container = Z_REFVAL_P(container);
40189
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
40190
0
        result = (opline->extended_value & ZEND_ISEMPTY);
40191
0
        goto isset_object_finish;
40192
0
      }
40193
0
    } else {
40194
0
      result = (opline->extended_value & ZEND_ISEMPTY);
40195
0
      goto isset_object_finish;
40196
0
    }
40197
0
  }
40198
40199
43
  if (IS_CV == IS_CONST) {
40200
0
    name = Z_STR_P(offset);
40201
43
  } else {
40202
43
    name = zval_try_get_tmp_string(offset, &tmp_name);
40203
43
    if (UNEXPECTED(!name)) {
40204
0
      result = 0;
40205
0
      goto isset_object_finish;
40206
0
    }
40207
43
  }
40208
40209
43
  result =
40210
43
    (opline->extended_value & ZEND_ISEMPTY) ^
40211
43
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
40212
40213
43
  if (IS_CV != IS_CONST) {
40214
43
    zend_tmp_string_release(tmp_name);
40215
43
  }
40216
40217
43
isset_object_finish:
40218
40219
40220
43
  ZEND_VM_SMART_BRANCH(result, 1);
40221
43
}
40222
40223
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40224
0
{
40225
0
  USE_OPLINE
40226
40227
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40228
40229
0
  SAVE_OPLINE();
40230
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
40231
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40232
0
  }
40233
40234
  /* Destroy the previously yielded value */
40235
0
  zval_ptr_dtor(&generator->value);
40236
40237
  /* Destroy the previously yielded key */
40238
0
  zval_ptr_dtor(&generator->key);
40239
40240
  /* Set the new yielded value */
40241
0
  if (IS_UNUSED != IS_UNUSED) {
40242
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
40243
      /* Constants and temporary variables aren't yieldable by reference,
40244
       * but we still allow them with a notice. */
40245
0
      if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
40246
0
        zval *value;
40247
40248
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
40249
40250
0
        value = NULL;
40251
0
        ZVAL_COPY_VALUE(&generator->value, value);
40252
0
        if (IS_UNUSED == IS_CONST) {
40253
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
40254
0
            Z_ADDREF(generator->value);
40255
0
          }
40256
0
        }
40257
0
      } else {
40258
0
        zval *value_ptr = NULL;
40259
40260
        /* If a function call result is yielded and the function did
40261
         * not return by reference we throw a notice. */
40262
0
        do {
40263
0
          if (IS_UNUSED == IS_VAR) {
40264
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
40265
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
40266
0
             && !Z_ISREF_P(value_ptr)) {
40267
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
40268
0
              ZVAL_COPY(&generator->value, value_ptr);
40269
0
              break;
40270
0
            }
40271
0
          }
40272
0
          if (Z_ISREF_P(value_ptr)) {
40273
0
            Z_ADDREF_P(value_ptr);
40274
0
          } else {
40275
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
40276
0
          }
40277
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
40278
0
        } while (0);
40279
40280
0
      }
40281
0
    } else {
40282
0
      zval *value = NULL;
40283
40284
      /* Consts, temporary variables and references need copying */
40285
0
      if (IS_UNUSED == IS_CONST) {
40286
0
        ZVAL_COPY_VALUE(&generator->value, value);
40287
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
40288
0
          Z_ADDREF(generator->value);
40289
0
        }
40290
0
      } else if (IS_UNUSED == IS_TMP_VAR) {
40291
0
        ZVAL_COPY_VALUE(&generator->value, value);
40292
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40293
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
40294
40295
0
      } else {
40296
0
        ZVAL_COPY_VALUE(&generator->value, value);
40297
0
        if (IS_UNUSED == IS_CV) {
40298
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
40299
0
        }
40300
0
      }
40301
0
    }
40302
0
  } else {
40303
    /* If no value was specified yield null */
40304
0
    ZVAL_NULL(&generator->value);
40305
0
  }
40306
40307
  /* Set the new yielded key */
40308
0
  if (IS_CV != IS_UNUSED) {
40309
0
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40310
0
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
40311
0
      key = Z_REFVAL_P(key);
40312
0
    }
40313
0
    ZVAL_COPY(&generator->key, key);
40314
40315
0
    if (Z_TYPE(generator->key) == IS_LONG
40316
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
40317
0
    ) {
40318
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
40319
0
    }
40320
0
  } else {
40321
    /* If no key was specified we use auto-increment keys */
40322
0
    generator->largest_used_integer_key++;
40323
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
40324
0
  }
40325
40326
0
  if (RETURN_VALUE_USED(opline)) {
40327
    /* If the return value of yield is used set the send
40328
     * target and initialize it to NULL */
40329
0
    generator->send_target = EX_VAR(opline->result.var);
40330
0
    ZVAL_NULL(generator->send_target);
40331
0
  } else {
40332
0
    generator->send_target = NULL;
40333
0
  }
40334
40335
  /* The GOTO VM uses a local opline variable. We need to set the opline
40336
   * variable in execute_data so we don't resume at an old position. */
40337
0
  SAVE_OPLINE();
40338
40339
0
  ZEND_VM_RETURN();
40340
0
}
40341
40342
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40343
11.5k
{
40344
11.5k
  USE_OPLINE
40345
11.5k
  zval *val;
40346
40347
11.5k
  val = EX_VAR(opline->op1.var);
40348
11.5k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40349
374
    ZVAL_FALSE(EX_VAR(opline->result.var));
40350
11.1k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40351
    /* The result and op1 can be the same cv zval */
40352
2.55k
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
40353
2.55k
    ZVAL_TRUE(EX_VAR(opline->result.var));
40354
2.55k
    if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
40355
2.01k
      SAVE_OPLINE();
40356
2.01k
      ZVAL_UNDEFINED_OP1();
40357
2.01k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40358
2.01k
    }
40359
8.59k
  } else {
40360
8.59k
    SAVE_OPLINE();
40361
8.59k
    ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
40362
40363
8.59k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40364
8.59k
  }
40365
920
  ZEND_VM_NEXT_OPCODE();
40366
920
}
40367
40368
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40369
6.06k
{
40370
6.06k
  USE_OPLINE
40371
6.06k
  zval *var_ptr;
40372
40373
6.06k
  var_ptr = EX_VAR(opline->op1.var);
40374
40375
6.06k
  SAVE_OPLINE();
40376
6.06k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40377
1.27k
    ZVAL_UNDEFINED_OP1();
40378
1.27k
    ZVAL_NULL(var_ptr);
40379
1.27k
  }
40380
40381
6.06k
  do {
40382
6.06k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40383
1.85k
      zend_reference *ref = Z_REF_P(var_ptr);
40384
1.85k
      var_ptr = Z_REFVAL_P(var_ptr);
40385
1.85k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40386
51
        zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
40387
51
        break;
40388
51
      }
40389
1.85k
    }
40390
6.01k
    increment_function(var_ptr);
40391
6.01k
  } while (0);
40392
40393
6.06k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
40394
914
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40395
914
  }
40396
40397
6.06k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40398
6.06k
}
40399
40400
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40401
71.6k
{
40402
71.6k
  USE_OPLINE
40403
71.6k
  zval *var_ptr;
40404
40405
71.6k
  var_ptr = EX_VAR(opline->op1.var);
40406
40407
71.6k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40408
66.4k
    fast_long_increment_function(var_ptr);
40409
66.4k
    if (UNEXPECTED(0)) {
40410
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40411
0
    }
40412
66.4k
    ZEND_VM_NEXT_OPCODE();
40413
66.4k
  }
40414
40415
71.6k
  ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40416
71.6k
}
40417
40418
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40419
5.45k
{
40420
5.45k
  USE_OPLINE
40421
5.45k
  zval *var_ptr;
40422
40423
5.45k
  var_ptr = EX_VAR(opline->op1.var);
40424
40425
5.45k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40426
4.53k
    fast_long_increment_function(var_ptr);
40427
4.53k
    if (UNEXPECTED(1)) {
40428
4.53k
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40429
4.53k
    }
40430
4.53k
    ZEND_VM_NEXT_OPCODE();
40431
4.53k
  }
40432
40433
5.45k
  ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40434
5.45k
}
40435
40436
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40437
2.37k
{
40438
2.37k
  USE_OPLINE
40439
2.37k
  zval *var_ptr;
40440
40441
2.37k
  var_ptr = EX_VAR(opline->op1.var);
40442
40443
2.37k
  SAVE_OPLINE();
40444
2.37k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40445
98
    ZVAL_UNDEFINED_OP1();
40446
98
    ZVAL_NULL(var_ptr);
40447
98
  }
40448
40449
2.37k
  do {
40450
2.37k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40451
62
      zend_reference *ref = Z_REF_P(var_ptr);
40452
62
      var_ptr = Z_REFVAL_P(var_ptr);
40453
40454
62
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40455
62
        zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
40456
62
        break;
40457
62
      }
40458
62
    }
40459
2.31k
    decrement_function(var_ptr);
40460
2.31k
  } while (0);
40461
40462
2.37k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
40463
996
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40464
996
  }
40465
40466
2.37k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40467
2.37k
}
40468
40469
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40470
1.93k
{
40471
1.93k
  USE_OPLINE
40472
1.93k
  zval *var_ptr;
40473
40474
1.93k
  var_ptr = EX_VAR(opline->op1.var);
40475
40476
1.93k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40477
553
    fast_long_decrement_function(var_ptr);
40478
553
    if (UNEXPECTED(0)) {
40479
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40480
0
    }
40481
553
    ZEND_VM_NEXT_OPCODE();
40482
553
  }
40483
40484
1.93k
  ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40485
1.93k
}
40486
40487
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40488
4.73k
{
40489
4.73k
  USE_OPLINE
40490
4.73k
  zval *var_ptr;
40491
40492
4.73k
  var_ptr = EX_VAR(opline->op1.var);
40493
40494
4.73k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40495
3.73k
    fast_long_decrement_function(var_ptr);
40496
3.73k
    if (UNEXPECTED(1)) {
40497
3.73k
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40498
3.73k
    }
40499
3.73k
    ZEND_VM_NEXT_OPCODE();
40500
3.73k
  }
40501
40502
4.73k
  ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40503
4.73k
}
40504
40505
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40506
344
{
40507
344
  USE_OPLINE
40508
344
  zval *var_ptr;
40509
40510
344
  var_ptr = EX_VAR(opline->op1.var);
40511
40512
344
  SAVE_OPLINE();
40513
344
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40514
161
    ZVAL_UNDEFINED_OP1();
40515
161
    ZVAL_NULL(var_ptr);
40516
161
  }
40517
40518
344
  do {
40519
344
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40520
94
      zend_reference *ref = Z_REF_P(var_ptr);
40521
94
      var_ptr = Z_REFVAL_P(var_ptr);
40522
40523
94
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40524
20
        zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
40525
20
        break;
40526
20
      }
40527
94
    }
40528
324
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40529
40530
324
    increment_function(var_ptr);
40531
324
  } while (0);
40532
40533
344
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40534
344
}
40535
40536
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40537
5.30k
{
40538
5.30k
  USE_OPLINE
40539
5.30k
  zval *var_ptr;
40540
40541
5.30k
  var_ptr = EX_VAR(opline->op1.var);
40542
40543
5.30k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40544
4.95k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40545
4.95k
    fast_long_increment_function(var_ptr);
40546
4.95k
    ZEND_VM_NEXT_OPCODE();
40547
4.95k
  }
40548
40549
5.30k
  ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40550
5.30k
}
40551
40552
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40553
15.2k
{
40554
15.2k
  USE_OPLINE
40555
15.2k
  zval *var_ptr;
40556
40557
15.2k
  var_ptr = EX_VAR(opline->op1.var);
40558
40559
15.2k
  SAVE_OPLINE();
40560
15.2k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40561
423
    ZVAL_UNDEFINED_OP1();
40562
423
    ZVAL_NULL(var_ptr);
40563
423
  }
40564
40565
15.2k
  do {
40566
15.2k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40567
1.96k
      zend_reference *ref = Z_REF_P(var_ptr);
40568
1.96k
      var_ptr = Z_REFVAL_P(var_ptr);
40569
40570
1.96k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40571
22
        zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
40572
22
        break;
40573
22
      }
40574
1.96k
    }
40575
15.2k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40576
40577
15.2k
    decrement_function(var_ptr);
40578
15.2k
  } while (0);
40579
40580
15.2k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40581
15.2k
}
40582
40583
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40584
34.0k
{
40585
34.0k
  USE_OPLINE
40586
34.0k
  zval *var_ptr;
40587
40588
34.0k
  var_ptr = EX_VAR(opline->op1.var);
40589
40590
34.0k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40591
18.7k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40592
18.7k
    fast_long_decrement_function(var_ptr);
40593
18.7k
    ZEND_VM_NEXT_OPCODE();
40594
18.7k
  }
40595
40596
34.0k
  ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40597
34.0k
}
40598
40599
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40600
2.84k
{
40601
2.84k
  USE_OPLINE
40602
2.84k
  zval *z;
40603
40604
2.84k
  SAVE_OPLINE();
40605
2.84k
  z = EX_VAR(opline->op1.var);
40606
40607
2.84k
  if (Z_TYPE_P(z) == IS_STRING) {
40608
1.23k
    zend_string *str = Z_STR_P(z);
40609
40610
1.23k
    if (ZSTR_LEN(str) != 0) {
40611
1.22k
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
40612
1.22k
    }
40613
1.61k
  } else {
40614
1.61k
    zend_string *str = zval_get_string_func(z);
40615
40616
1.61k
    if (ZSTR_LEN(str) != 0) {
40617
513
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
40618
1.10k
    } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
40619
997
      ZVAL_UNDEFINED_OP1();
40620
997
    }
40621
1.61k
    zend_string_release_ex(str, 0);
40622
1.61k
  }
40623
40624
2.84k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40625
2.84k
}
40626
40627
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40628
6.78k
{
40629
6.78k
  USE_OPLINE
40630
6.78k
  zval *val;
40631
6.78k
  uint8_t op1_type;
40632
40633
6.78k
  val = EX_VAR(opline->op1.var);
40634
40635
6.78k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40636
753
    ZEND_VM_NEXT_OPCODE();
40637
6.03k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40638
1.31k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40639
433
      SAVE_OPLINE();
40640
433
      ZVAL_UNDEFINED_OP1();
40641
433
      if (UNEXPECTED(EG(exception))) {
40642
5
        HANDLE_EXCEPTION();
40643
5
      }
40644
433
    }
40645
1.31k
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40646
1.31k
  }
40647
40648
6.78k
  SAVE_OPLINE();
40649
4.71k
  op1_type = IS_CV;
40650
4.71k
  if (i_zend_is_true(val)) {
40651
2.48k
    opline++;
40652
2.48k
  } else {
40653
2.23k
    opline = OP_JMP_ADDR(opline, opline->op2);
40654
2.23k
  }
40655
4.71k
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
40656
0
    zval_ptr_dtor_nogc(val);
40657
0
  }
40658
4.71k
  ZEND_VM_JMP(opline);
40659
4.71k
}
40660
40661
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40662
8.18k
{
40663
8.18k
  USE_OPLINE
40664
8.18k
  zval *val;
40665
8.18k
  uint8_t op1_type;
40666
40667
8.18k
  val = EX_VAR(opline->op1.var);
40668
40669
8.18k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40670
13
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40671
8.17k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40672
3.44k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40673
2.44k
      SAVE_OPLINE();
40674
2.44k
      ZVAL_UNDEFINED_OP1();
40675
2.44k
      if (UNEXPECTED(EG(exception))) {
40676
0
        HANDLE_EXCEPTION();
40677
0
      }
40678
2.44k
    }
40679
3.44k
    ZEND_VM_NEXT_OPCODE();
40680
3.44k
  }
40681
40682
8.18k
  SAVE_OPLINE();
40683
4.73k
  op1_type = IS_CV;
40684
4.73k
  if (i_zend_is_true(val)) {
40685
2.24k
    opline = OP_JMP_ADDR(opline, opline->op2);
40686
2.48k
  } else {
40687
2.48k
    opline++;
40688
2.48k
  }
40689
4.73k
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
40690
0
    zval_ptr_dtor_nogc(val);
40691
0
  }
40692
4.73k
  ZEND_VM_JMP(opline);
40693
4.73k
}
40694
40695
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40696
19
{
40697
19
  USE_OPLINE
40698
19
  zval *val;
40699
19
  bool ret;
40700
40701
19
  val = EX_VAR(opline->op1.var);
40702
40703
19
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40704
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
40705
0
    ZEND_VM_NEXT_OPCODE();
40706
19
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40707
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
40708
0
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40709
0
      SAVE_OPLINE();
40710
0
      ZVAL_UNDEFINED_OP1();
40711
0
      if (UNEXPECTED(EG(exception))) {
40712
0
        HANDLE_EXCEPTION();
40713
0
      }
40714
0
    }
40715
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40716
0
  }
40717
40718
19
  SAVE_OPLINE();
40719
19
  ret = i_zend_is_true(val);
40720
40721
19
  if (ret) {
40722
12
    ZVAL_TRUE(EX_VAR(opline->result.var));
40723
12
    opline++;
40724
12
  } else {
40725
7
    ZVAL_FALSE(EX_VAR(opline->result.var));
40726
7
    opline = OP_JMP_ADDR(opline, opline->op2);
40727
7
  }
40728
19
  ZEND_VM_JMP(opline);
40729
19
}
40730
40731
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40732
44
{
40733
44
  USE_OPLINE
40734
44
  zval *val;
40735
44
  bool ret;
40736
40737
44
  val = EX_VAR(opline->op1.var);
40738
40739
44
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40740
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
40741
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40742
44
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40743
2
    ZVAL_FALSE(EX_VAR(opline->result.var));
40744
2
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40745
2
      SAVE_OPLINE();
40746
2
      ZVAL_UNDEFINED_OP1();
40747
2
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40748
2
    } else {
40749
0
      ZEND_VM_NEXT_OPCODE();
40750
0
    }
40751
2
  }
40752
40753
44
  SAVE_OPLINE();
40754
42
  ret = i_zend_is_true(val);
40755
40756
42
  if (ret) {
40757
31
    ZVAL_TRUE(EX_VAR(opline->result.var));
40758
31
    opline = OP_JMP_ADDR(opline, opline->op2);
40759
31
  } else {
40760
11
    ZVAL_FALSE(EX_VAR(opline->result.var));
40761
11
    opline++;
40762
11
  }
40763
42
  ZEND_VM_JMP(opline);
40764
42
}
40765
40766
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40767
3.84k
{
40768
3.84k
  USE_OPLINE
40769
3.84k
  zval *retval_ptr;
40770
3.84k
  zval *return_value;
40771
40772
3.84k
  retval_ptr = EX_VAR(opline->op1.var);
40773
3.84k
  return_value = EX(return_value);
40774
40775
3.84k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
40776
319
    SAVE_OPLINE();
40777
319
    retval_ptr = ZVAL_UNDEFINED_OP1();
40778
319
    if (return_value) {
40779
222
      ZVAL_NULL(return_value);
40780
222
    }
40781
3.52k
  } else if (!return_value) {
40782
298
    if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
40783
0
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
40784
0
        SAVE_OPLINE();
40785
0
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
40786
0
      }
40787
0
    }
40788
3.23k
  } else {
40789
3.23k
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
40790
0
      ZVAL_COPY_VALUE(return_value, retval_ptr);
40791
0
      if (IS_CV == IS_CONST) {
40792
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
40793
0
          Z_ADDREF_P(return_value);
40794
0
        }
40795
0
      }
40796
3.23k
    } else if (IS_CV == IS_CV) {
40797
3.23k
      do {
40798
3.23k
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40799
1.41k
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
40800
977
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
40801
977
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
40802
977
              ZVAL_COPY_VALUE(return_value, retval_ptr);
40803
977
              if (GC_MAY_LEAK(ref)) {
40804
524
                SAVE_OPLINE();
40805
524
                gc_possible_root(ref);
40806
524
              }
40807
977
              ZVAL_NULL(retval_ptr);
40808
977
              break;
40809
977
            } else {
40810
0
              Z_ADDREF_P(retval_ptr);
40811
0
            }
40812
977
          } else {
40813
435
            retval_ptr = Z_REFVAL_P(retval_ptr);
40814
435
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40815
233
              Z_ADDREF_P(retval_ptr);
40816
233
            }
40817
435
          }
40818
1.41k
        }
40819
2.25k
        ZVAL_COPY_VALUE(return_value, retval_ptr);
40820
2.25k
      } while (0);
40821
3.23k
    } else /* if (IS_CV == IS_VAR) */ {
40822
0
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
40823
0
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
40824
40825
0
        retval_ptr = Z_REFVAL_P(retval_ptr);
40826
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
40827
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40828
0
          efree_size(ref, sizeof(zend_reference));
40829
0
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40830
0
          Z_ADDREF_P(retval_ptr);
40831
0
        }
40832
0
      } else {
40833
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
40834
0
      }
40835
0
    }
40836
3.23k
  }
40837
40838
40839
40840
3.84k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40841
3.84k
}
40842
40843
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40844
1.31k
{
40845
1.31k
  USE_OPLINE
40846
1.31k
  zval *retval_ptr;
40847
1.31k
  zval *return_value;
40848
40849
1.31k
  SAVE_OPLINE();
40850
40851
1.31k
  return_value = EX(return_value);
40852
40853
1.31k
  do {
40854
1.31k
    if ((IS_CV & (IS_CONST|IS_TMP_VAR)) ||
40855
1.31k
        (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
40856
      /* Not supposed to happen, but we'll allow it */
40857
0
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
40858
40859
0
      retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40860
0
      if (!return_value) {
40861
40862
0
      } else {
40863
0
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
40864
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
40865
0
          break;
40866
0
        }
40867
40868
0
        ZVAL_NEW_REF(return_value, retval_ptr);
40869
0
        if (IS_CV == IS_CONST) {
40870
0
          Z_TRY_ADDREF_P(retval_ptr);
40871
0
        }
40872
0
      }
40873
0
      break;
40874
0
    }
40875
40876
1.31k
    retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
40877
40878
1.31k
    if (IS_CV == IS_VAR) {
40879
0
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
40880
0
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
40881
0
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
40882
0
        if (return_value) {
40883
0
          ZVAL_NEW_REF(return_value, retval_ptr);
40884
0
        } else {
40885
40886
0
        }
40887
0
        break;
40888
0
      }
40889
0
    }
40890
40891
1.31k
    if (return_value) {
40892
1.28k
      if (Z_ISREF_P(retval_ptr)) {
40893
602
        Z_ADDREF_P(retval_ptr);
40894
686
      } else {
40895
686
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
40896
686
      }
40897
1.28k
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
40898
1.28k
    }
40899
40900
1.31k
  } while (0);
40901
40902
40903
1.31k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40904
1.31k
}
40905
40906
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40907
5
{
40908
5
  USE_OPLINE
40909
5
  zval *retval;
40910
40911
5
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40912
40913
5
  SAVE_OPLINE();
40914
5
  retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40915
40916
  /* Copy return value into generator->retval */
40917
5
  if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
40918
0
    ZVAL_COPY_VALUE(&generator->retval, retval);
40919
0
    if (IS_CV == IS_CONST) {
40920
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
40921
0
        Z_ADDREF(generator->retval);
40922
0
      }
40923
0
    }
40924
5
  } else if (IS_CV == IS_CV) {
40925
5
    ZVAL_COPY_DEREF(&generator->retval, retval);
40926
5
  } else /* if (IS_CV == IS_VAR) */ {
40927
0
    if (UNEXPECTED(Z_ISREF_P(retval))) {
40928
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
40929
40930
0
      retval = Z_REFVAL_P(retval);
40931
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
40932
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40933
0
        efree_size(ref, sizeof(zend_reference));
40934
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
40935
0
        Z_ADDREF_P(retval);
40936
0
      }
40937
0
    } else {
40938
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
40939
0
    }
40940
0
  }
40941
40942
5
  EG(current_execute_data) = EX(prev_execute_data);
40943
40944
  /* Close the generator to free up resources */
40945
5
  zend_generator_close(generator, 1);
40946
40947
  /* Pass execution back to handling code */
40948
5
  ZEND_VM_RETURN();
40949
5
}
40950
40951
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40952
89
{
40953
89
  USE_OPLINE
40954
89
  zval *value;
40955
40956
89
  SAVE_OPLINE();
40957
89
  value = EX_VAR(opline->op1.var);
40958
40959
89
  do {
40960
89
    if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
40961
20
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40962
5
        value = Z_REFVAL_P(value);
40963
5
        if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
40964
5
          break;
40965
5
        }
40966
5
      }
40967
15
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40968
15
        ZVAL_UNDEFINED_OP1();
40969
15
        if (UNEXPECTED(EG(exception) != NULL)) {
40970
7
          HANDLE_EXCEPTION();
40971
7
        }
40972
15
      }
40973
8
      zend_throw_error(NULL, "Can only throw objects");
40974
40975
8
      HANDLE_EXCEPTION();
40976
8
    }
40977
89
  } while (0);
40978
40979
74
  zend_exception_save();
40980
74
  Z_TRY_ADDREF_P(value);
40981
74
  zend_throw_exception_object(value);
40982
74
  zend_exception_restore();
40983
40984
74
  HANDLE_EXCEPTION();
40985
74
}
40986
40987
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40988
2.74k
{
40989
2.74k
  USE_OPLINE
40990
2.74k
  zval *arg, *param;
40991
40992
2.74k
  SAVE_OPLINE();
40993
40994
2.74k
  arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40995
2.74k
  param = ZEND_CALL_VAR(EX(call), opline->result.var);
40996
2.74k
  if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
40997
43
    zend_param_must_be_ref(EX(call)->func, opline->op2.num);
40998
43
    Z_TRY_ADDREF_P(arg);
40999
43
    ZVAL_NEW_REF(param, arg);
41000
2.69k
  } else {
41001
2.69k
    ZVAL_COPY(param, arg);
41002
2.69k
  }
41003
41004
2.74k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41005
2.74k
}
41006
41007
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41008
691
{
41009
691
  USE_OPLINE
41010
691
  zval *val;
41011
41012
691
  val = EX_VAR(opline->op1.var);
41013
691
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
41014
78
    ZVAL_TRUE(EX_VAR(opline->result.var));
41015
613
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
41016
    /* The result and op1 can be the same cv zval */
41017
91
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
41018
91
    ZVAL_FALSE(EX_VAR(opline->result.var));
41019
91
    if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
41020
12
      SAVE_OPLINE();
41021
12
      ZVAL_UNDEFINED_OP1();
41022
12
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41023
12
    }
41024
522
  } else {
41025
522
    SAVE_OPLINE();
41026
522
    ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
41027
41028
522
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41029
522
  }
41030
157
  ZEND_VM_NEXT_OPCODE();
41031
157
}
41032
41033
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41034
395
{
41035
395
  USE_OPLINE
41036
395
  zval *obj;
41037
395
  zend_object *zobj;
41038
395
  zend_class_entry *ce, *scope;
41039
395
  zend_function *clone;
41040
395
  zend_object_clone_obj_t clone_call;
41041
41042
395
  SAVE_OPLINE();
41043
395
  obj = EX_VAR(opline->op1.var);
41044
41045
395
  do {
41046
395
    if (IS_CV == IS_CONST ||
41047
395
        (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
41048
26
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
41049
0
        obj = Z_REFVAL_P(obj);
41050
0
        if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
41051
0
          break;
41052
0
        }
41053
0
      }
41054
26
      ZVAL_UNDEF(EX_VAR(opline->result.var));
41055
26
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
41056
24
        ZVAL_UNDEFINED_OP1();
41057
24
        if (UNEXPECTED(EG(exception) != NULL)) {
41058
7
          HANDLE_EXCEPTION();
41059
7
        }
41060
24
      }
41061
19
      zend_throw_error(NULL, "__clone method called on non-object");
41062
41063
19
      HANDLE_EXCEPTION();
41064
19
    }
41065
395
  } while (0);
41066
41067
369
  zobj = Z_OBJ_P(obj);
41068
369
  ce = zobj->ce;
41069
369
  clone = ce->clone;
41070
369
  clone_call = zobj->handlers->clone_obj;
41071
369
  if (UNEXPECTED(clone_call == NULL)) {
41072
5
    zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
41073
41074
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41075
5
    HANDLE_EXCEPTION();
41076
5
  }
41077
41078
364
  if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
41079
5
    scope = EX(func)->op_array.scope;
41080
5
    if (clone->common.scope != scope) {
41081
5
      if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
41082
5
       || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
41083
0
        zend_wrong_clone_call(clone, scope);
41084
41085
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
41086
0
        HANDLE_EXCEPTION();
41087
0
      }
41088
5
    }
41089
5
  }
41090
41091
364
  ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
41092
41093
364
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41094
364
}
41095
41096
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41097
3.89k
{
41098
3.89k
  USE_OPLINE
41099
3.89k
  zval *expr;
41100
3.89k
  zval *result = EX_VAR(opline->result.var);
41101
41102
3.89k
  SAVE_OPLINE();
41103
3.89k
  expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41104
41105
3.89k
  switch (opline->extended_value) {
41106
1.41k
    case IS_LONG:
41107
1.41k
      ZVAL_LONG(result, zval_get_long(expr));
41108
1.41k
      break;
41109
128
    case IS_DOUBLE:
41110
128
      ZVAL_DOUBLE(result, zval_get_double(expr));
41111
128
      break;
41112
1.44k
    case IS_STRING:
41113
1.44k
      ZVAL_STR(result, zval_get_string(expr));
41114
1.44k
      break;
41115
907
    default:
41116
907
      ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
41117
907
      if (IS_CV & (IS_VAR|IS_CV)) {
41118
907
        ZVAL_DEREF(expr);
41119
907
      }
41120
      /* If value is already of correct type, return it directly */
41121
907
      if (Z_TYPE_P(expr) == opline->extended_value) {
41122
644
        ZVAL_COPY_VALUE(result, expr);
41123
644
        if (IS_CV == IS_CONST) {
41124
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41125
644
        } else if (IS_CV != IS_TMP_VAR) {
41126
644
          if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41127
644
        }
41128
41129
644
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41130
644
      }
41131
41132
263
      if (opline->extended_value == IS_ARRAY) {
41133
209
        zend_cast_zval_to_array(result, expr, IS_CV);
41134
209
      } else {
41135
54
        ZEND_ASSERT(opline->extended_value == IS_OBJECT);
41136
54
        zend_cast_zval_to_object(result, expr, IS_CV);
41137
54
      }
41138
3.89k
  }
41139
41140
3.24k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41141
3.24k
}
41142
41143
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41144
1.42k
{
41145
1.42k
  USE_OPLINE
41146
1.42k
  zend_op_array *new_op_array;
41147
1.42k
  zval *inc_filename;
41148
41149
1.42k
  SAVE_OPLINE();
41150
1.42k
  inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41151
1.42k
  new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
41152
1.42k
  if (UNEXPECTED(EG(exception) != NULL)) {
41153
41154
830
    if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
41155
0
      destroy_op_array(new_op_array);
41156
0
      efree_size(new_op_array, sizeof(zend_op_array));
41157
0
    }
41158
830
    UNDEF_RESULT();
41159
830
    HANDLE_EXCEPTION();
41160
830
  } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
41161
1
    if (RETURN_VALUE_USED(opline)) {
41162
0
      ZVAL_TRUE(EX_VAR(opline->result.var));
41163
0
    }
41164
598
  } else if (UNEXPECTED(new_op_array == NULL)) {
41165
97
    if (RETURN_VALUE_USED(opline)) {
41166
48
      ZVAL_FALSE(EX_VAR(opline->result.var));
41167
48
    }
41168
501
  } else if (new_op_array->last == 1
41169
501
      && new_op_array->opcodes[0].opcode == ZEND_RETURN
41170
501
      && new_op_array->opcodes[0].op1_type == IS_CONST
41171
501
      && EXPECTED(zend_execute_ex == execute_ex)) {
41172
8
    if (RETURN_VALUE_USED(opline)) {
41173
0
      const zend_op *op = new_op_array->opcodes;
41174
41175
0
      ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
41176
0
    }
41177
8
    zend_destroy_static_vars(new_op_array);
41178
8
    destroy_op_array(new_op_array);
41179
8
    efree_size(new_op_array, sizeof(zend_op_array));
41180
493
  } else {
41181
493
    zval *return_value = NULL;
41182
493
    zend_execute_data *call;
41183
493
    if (RETURN_VALUE_USED(opline)) {
41184
462
      return_value = EX_VAR(opline->result.var);
41185
462
    }
41186
41187
493
    new_op_array->scope = EX(func)->op_array.scope;
41188
41189
493
    call = zend_vm_stack_push_call_frame(
41190
493
      (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
41191
493
      (zend_function*)new_op_array, 0,
41192
493
      Z_PTR(EX(This)));
41193
41194
493
    if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
41195
27
      call->symbol_table = EX(symbol_table);
41196
466
    } else {
41197
466
      call->symbol_table = zend_rebuild_symbol_table();
41198
466
    }
41199
41200
493
    call->prev_execute_data = execute_data;
41201
493
    i_init_code_execute_data(call, new_op_array, return_value);
41202
41203
493
    if (EXPECTED(zend_execute_ex == execute_ex)) {
41204
41205
301
      ZEND_VM_ENTER();
41206
301
    } else {
41207
192
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
41208
192
      zend_execute_ex(call);
41209
192
      zend_vm_stack_free_call_frame(call);
41210
192
    }
41211
41212
192
    zend_destroy_static_vars(new_op_array);
41213
192
    destroy_op_array(new_op_array);
41214
192
    efree_size(new_op_array, sizeof(zend_op_array));
41215
192
    if (UNEXPECTED(EG(exception) != NULL)) {
41216
100
      zend_rethrow_exception(execute_data);
41217
41218
100
      UNDEF_RESULT();
41219
100
      HANDLE_EXCEPTION();
41220
100
    }
41221
192
  }
41222
41223
198
  ZEND_VM_NEXT_OPCODE();
41224
198
}
41225
41226
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41227
19.8k
{
41228
19.8k
  USE_OPLINE
41229
19.8k
  zval *array_ptr, *result;
41230
41231
19.8k
  SAVE_OPLINE();
41232
41233
19.8k
  array_ptr = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41234
19.8k
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
41235
17.0k
    result = EX_VAR(opline->result.var);
41236
17.0k
    ZVAL_COPY_VALUE(result, array_ptr);
41237
17.0k
    if (IS_CV != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
41238
3.84k
      Z_ADDREF_P(array_ptr);
41239
3.84k
    }
41240
17.0k
    Z_FE_POS_P(result) = 0;
41241
41242
17.0k
    ZEND_VM_NEXT_OPCODE();
41243
17.0k
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
41244
941
    zend_object *zobj = Z_OBJ_P(array_ptr);
41245
941
    if (!zobj->ce->get_iterator) {
41246
167
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
41247
53
        zobj = zend_lazy_object_init(zobj);
41248
53
        if (UNEXPECTED(EG(exception))) {
41249
14
          UNDEF_RESULT();
41250
41251
14
          HANDLE_EXCEPTION();
41252
14
        }
41253
53
      }
41254
153
      HashTable *properties = zobj->properties;
41255
153
      if (properties) {
41256
110
        if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
41257
8
          if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
41258
8
            GC_DELREF(properties);
41259
8
          }
41260
8
          properties = zobj->properties = zend_array_dup(properties);
41261
8
        }
41262
110
      } else {
41263
43
        properties = zobj->handlers->get_properties(zobj);
41264
43
      }
41265
41266
153
      result = EX_VAR(opline->result.var);
41267
153
      ZVAL_COPY_VALUE(result, array_ptr);
41268
153
      if (IS_CV != IS_TMP_VAR) {
41269
153
        Z_ADDREF_P(array_ptr);
41270
153
      }
41271
41272
153
      if (zend_hash_num_elements(properties) == 0) {
41273
11
        Z_FE_ITER_P(result) = (uint32_t) -1;
41274
41275
11
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41276
11
      }
41277
41278
142
      Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
41279
41280
142
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41281
774
    } else {
41282
774
      bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
41283
41284
774
      if (UNEXPECTED(EG(exception))) {
41285
96
        HANDLE_EXCEPTION();
41286
678
      } else if (is_empty) {
41287
18
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41288
660
      } else {
41289
660
        ZEND_VM_NEXT_OPCODE();
41290
660
      }
41291
774
    }
41292
1.83k
  } else {
41293
1.83k
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
41294
1.83k
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41295
1.83k
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
41296
41297
1.83k
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41298
1.83k
  }
41299
19.8k
}
41300
41301
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41302
1.39k
{
41303
1.39k
  USE_OPLINE
41304
1.39k
  zval *array_ptr, *array_ref;
41305
41306
1.39k
  SAVE_OPLINE();
41307
41308
1.39k
  if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41309
1.39k
    array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41310
1.39k
    if (Z_ISREF_P(array_ref)) {
41311
287
      array_ptr = Z_REFVAL_P(array_ref);
41312
287
    }
41313
1.39k
  } else {
41314
0
    array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41315
0
  }
41316
41317
1.39k
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
41318
762
    if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41319
762
      if (array_ptr == array_ref) {
41320
507
        ZVAL_NEW_REF(array_ref, array_ref);
41321
507
        array_ptr = Z_REFVAL_P(array_ref);
41322
507
      }
41323
762
      Z_ADDREF_P(array_ref);
41324
762
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
41325
762
    } else {
41326
0
      array_ref = EX_VAR(opline->result.var);
41327
0
      ZVAL_NEW_REF(array_ref, array_ptr);
41328
0
      array_ptr = Z_REFVAL_P(array_ref);
41329
0
    }
41330
762
    if (IS_CV == IS_CONST) {
41331
0
      ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
41332
762
    } else {
41333
762
      SEPARATE_ARRAY(array_ptr);
41334
762
    }
41335
762
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
41336
41337
762
    ZEND_VM_NEXT_OPCODE();
41338
762
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
41339
271
    if (!Z_OBJCE_P(array_ptr)->get_iterator) {
41340
68
      zend_object *zobj = Z_OBJ_P(array_ptr);
41341
68
      HashTable *properties;
41342
68
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
41343
41
        zobj = zend_lazy_object_init(zobj);
41344
41
        if (UNEXPECTED(EG(exception))) {
41345
8
          UNDEF_RESULT();
41346
41347
8
          HANDLE_EXCEPTION();
41348
8
        }
41349
41
      }
41350
60
      if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41351
60
        if (array_ptr == array_ref) {
41352
36
          ZVAL_NEW_REF(array_ref, array_ref);
41353
36
          array_ptr = Z_REFVAL_P(array_ref);
41354
36
        }
41355
60
        Z_ADDREF_P(array_ref);
41356
60
        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
41357
60
      } else {
41358
0
        array_ptr = EX_VAR(opline->result.var);
41359
0
        ZVAL_COPY_VALUE(array_ptr, array_ref);
41360
0
      }
41361
60
      if (Z_OBJ_P(array_ptr)->properties
41362
60
       && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
41363
0
        if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
41364
0
          GC_DELREF(Z_OBJ_P(array_ptr)->properties);
41365
0
        }
41366
0
        Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
41367
0
      }
41368
41369
60
      properties = Z_OBJPROP_P(array_ptr);
41370
60
      if (zend_hash_num_elements(properties) == 0) {
41371
0
        Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
41372
41373
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41374
0
      }
41375
41376
60
      Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
41377
41378
60
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41379
203
    } else {
41380
203
      bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
41381
41382
203
      if (UNEXPECTED(EG(exception))) {
41383
13
        HANDLE_EXCEPTION();
41384
190
      } else if (is_empty) {
41385
8
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41386
182
      } else {
41387
182
        ZEND_VM_NEXT_OPCODE();
41388
182
      }
41389
203
    }
41390
360
  } else {
41391
360
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
41392
360
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41393
360
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
41394
41395
360
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41396
360
  }
41397
1.39k
}
41398
41399
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41400
196
{
41401
196
  USE_OPLINE
41402
196
  zval *value;
41403
196
  zend_reference *ref = NULL;
41404
196
  bool ret;
41405
41406
196
  SAVE_OPLINE();
41407
196
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41408
41409
196
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) {
41410
0
    if (IS_CV == IS_VAR) {
41411
0
      ref = Z_REF_P(value);
41412
0
    }
41413
0
    value = Z_REFVAL_P(value);
41414
0
  }
41415
41416
196
  ret = i_zend_is_true(value);
41417
41418
196
  if (UNEXPECTED(EG(exception))) {
41419
41420
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41421
0
    HANDLE_EXCEPTION();
41422
0
  }
41423
41424
196
  if (ret) {
41425
115
    zval *result = EX_VAR(opline->result.var);
41426
41427
115
    ZVAL_COPY_VALUE(result, value);
41428
115
    if (IS_CV == IS_CONST) {
41429
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41430
115
    } else if (IS_CV == IS_CV) {
41431
115
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41432
115
    } else if (IS_CV == IS_VAR && ref) {
41433
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41434
0
        efree_size(ref, sizeof(zend_reference));
41435
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
41436
0
        Z_ADDREF_P(result);
41437
0
      }
41438
0
    }
41439
115
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41440
115
  }
41441
41442
81
  ZEND_VM_NEXT_OPCODE();
41443
81
}
41444
41445
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41446
156
{
41447
156
  USE_OPLINE
41448
156
  zval *value;
41449
156
  zend_reference *ref = NULL;
41450
41451
156
  SAVE_OPLINE();
41452
156
  value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
41453
41454
156
  if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
41455
0
    if (IS_CV & IS_VAR) {
41456
0
      ref = Z_REF_P(value);
41457
0
    }
41458
0
    value = Z_REFVAL_P(value);
41459
0
  }
41460
41461
156
  if (Z_TYPE_P(value) > IS_NULL) {
41462
53
    zval *result = EX_VAR(opline->result.var);
41463
53
    ZVAL_COPY_VALUE(result, value);
41464
53
    if (IS_CV == IS_CONST) {
41465
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41466
53
    } else if (IS_CV == IS_CV) {
41467
53
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41468
53
    } else if ((IS_CV & IS_VAR) && ref) {
41469
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41470
0
        efree_size(ref, sizeof(zend_reference));
41471
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
41472
0
        Z_ADDREF_P(result);
41473
0
      }
41474
0
    }
41475
53
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41476
53
  }
41477
41478
103
  if ((IS_CV & IS_VAR) && ref) {
41479
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41480
0
      efree_size(ref, sizeof(zend_reference));
41481
0
    }
41482
0
  }
41483
103
  ZEND_VM_NEXT_OPCODE();
41484
103
}
41485
41486
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41487
62.6k
{
41488
62.6k
  USE_OPLINE
41489
62.6k
  zval *val, *result;
41490
41491
62.6k
  val = EX_VAR(opline->op1.var);
41492
41493
62.6k
  if (Z_TYPE_P(val) > IS_NULL) {
41494
306
    do {
41495
306
      if ((IS_CV == IS_CV || IS_CV == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
41496
17
        val = Z_REFVAL_P(val);
41497
17
        if (Z_TYPE_P(val) <= IS_NULL) {
41498
41499
12
          break;
41500
12
        }
41501
17
      }
41502
294
      ZEND_VM_NEXT_OPCODE();
41503
294
    } while (0);
41504
306
  }
41505
41506
62.3k
  result = EX_VAR(opline->result.var);
41507
62.3k
  uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
41508
62.3k
  if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
41509
62.2k
    ZVAL_NULL(result);
41510
62.2k
    if (IS_CV == IS_CV
41511
62.2k
      && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
41512
62.2k
      && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
41513
62.2k
    ) {
41514
61.9k
      SAVE_OPLINE();
41515
61.9k
      ZVAL_UNDEFINED_OP1();
41516
61.9k
      if (UNEXPECTED(EG(exception) != NULL)) {
41517
5
        HANDLE_EXCEPTION();
41518
5
      }
41519
61.9k
    }
41520
62.2k
  } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
41521
37
    ZVAL_FALSE(result);
41522
37
  } else {
41523
37
    ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
41524
37
    ZVAL_TRUE(result);
41525
37
  }
41526
41527
62.3k
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41528
62.3k
}
41529
41530
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41531
13.4k
{
41532
13.4k
  USE_OPLINE
41533
13.4k
  zval *value;
41534
13.4k
  zval *result = EX_VAR(opline->result.var);
41535
41536
13.4k
  value = EX_VAR(opline->op1.var);
41537
13.4k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41538
7.98k
    SAVE_OPLINE();
41539
7.98k
    ZVAL_UNDEFINED_OP1();
41540
7.98k
    ZVAL_NULL(result);
41541
7.98k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41542
7.98k
  }
41543
41544
5.46k
  if (IS_CV == IS_CV) {
41545
5.46k
    ZVAL_COPY_DEREF(result, value);
41546
5.46k
  } else if (IS_CV == IS_VAR) {
41547
0
    if (UNEXPECTED(Z_ISREF_P(value))) {
41548
0
      ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
41549
0
      if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
41550
0
        efree_size(Z_REF_P(value), sizeof(zend_reference));
41551
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
41552
0
        Z_ADDREF_P(result);
41553
0
      }
41554
0
    } else {
41555
0
      ZVAL_COPY_VALUE(result, value);
41556
0
    }
41557
0
  } else {
41558
0
    ZVAL_COPY_VALUE(result, value);
41559
0
    if (IS_CV == IS_CONST) {
41560
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
41561
0
        Z_ADDREF_P(result);
41562
0
      }
41563
0
    }
41564
0
  }
41565
5.46k
  ZEND_VM_NEXT_OPCODE();
41566
5.46k
}
41567
41568
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41569
456
{
41570
456
  USE_OPLINE
41571
456
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
41572
456
  zval *val;
41573
41574
456
  SAVE_OPLINE();
41575
456
  val = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41576
41577
456
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
41578
0
    zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
41579
41580
0
    UNDEF_RESULT();
41581
0
    HANDLE_EXCEPTION();
41582
0
  }
41583
41584
456
yield_from_try_again:
41585
456
  if (Z_TYPE_P(val) == IS_ARRAY) {
41586
8
    ZVAL_COPY_VALUE(&generator->values, val);
41587
8
    if (Z_OPT_REFCOUNTED_P(val)) {
41588
0
      Z_ADDREF_P(val);
41589
0
    }
41590
8
    Z_FE_POS(generator->values) = 0;
41591
41592
448
  } else if (IS_CV != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
41593
427
    zend_class_entry *ce = Z_OBJCE_P(val);
41594
427
    if (ce == zend_ce_generator) {
41595
412
      zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
41596
41597
412
      Z_ADDREF_P(val);
41598
41599
412
      if (UNEXPECTED(new_gen->execute_data == NULL)) {
41600
8
        zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
41601
8
        zval_ptr_dtor(val);
41602
8
        UNDEF_RESULT();
41603
8
        HANDLE_EXCEPTION();
41604
404
      } else if (Z_ISUNDEF(new_gen->retval)) {
41605
404
        if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
41606
0
          zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
41607
0
          zval_ptr_dtor(val);
41608
0
          UNDEF_RESULT();
41609
0
          HANDLE_EXCEPTION();
41610
404
        } else {
41611
404
          zend_generator_yield_from(generator, new_gen);
41612
404
        }
41613
404
      } else {
41614
0
        if (RETURN_VALUE_USED(opline)) {
41615
0
          ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
41616
0
        }
41617
0
        ZEND_VM_NEXT_OPCODE();
41618
0
      }
41619
412
    } else {
41620
15
      zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
41621
41622
15
      if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
41623
0
        if (!EG(exception)) {
41624
0
          zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
41625
0
        }
41626
0
        UNDEF_RESULT();
41627
0
        HANDLE_EXCEPTION();
41628
0
      }
41629
41630
15
      iter->index = 0;
41631
15
      if (iter->funcs->rewind) {
41632
15
        iter->funcs->rewind(iter);
41633
15
        if (UNEXPECTED(EG(exception) != NULL)) {
41634
5
          OBJ_RELEASE(&iter->std);
41635
5
          UNDEF_RESULT();
41636
5
          HANDLE_EXCEPTION();
41637
5
        }
41638
15
      }
41639
41640
10
      ZVAL_OBJ(&generator->values, &iter->std);
41641
10
    }
41642
427
  } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
41643
0
    val = Z_REFVAL_P(val);
41644
0
    goto yield_from_try_again;
41645
21
  } else {
41646
21
    zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
41647
41648
21
    UNDEF_RESULT();
41649
21
    HANDLE_EXCEPTION();
41650
21
  }
41651
41652
  /* This is the default return value
41653
   * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
41654
422
  if (RETURN_VALUE_USED(opline)) {
41655
422
    ZVAL_NULL(EX_VAR(opline->result.var));
41656
422
  }
41657
41658
  /* This generator has no send target (though the generator we delegate to might have one) */
41659
422
  generator->send_target = NULL;
41660
41661
  /* The GOTO VM uses a local opline variable. We need to set the opline
41662
   * variable in execute_data so we don't resume at an old position. */
41663
422
  SAVE_OPLINE();
41664
41665
422
  ZEND_VM_RETURN();
41666
456
}
41667
41668
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41669
314
{
41670
314
  USE_OPLINE
41671
314
  zval *value;
41672
41673
314
  value = EX_VAR(opline->op1.var);
41674
314
  if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
41675
267
    ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
41676
267
    if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41677
0
      zval_ptr_dtor_str(value);
41678
0
    }
41679
267
    ZEND_VM_NEXT_OPCODE();
41680
267
  } else {
41681
47
    bool strict;
41682
41683
47
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
41684
0
      value = Z_REFVAL_P(value);
41685
0
      if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
41686
0
        ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
41687
41688
0
        ZEND_VM_NEXT_OPCODE();
41689
0
      }
41690
0
    }
41691
41692
47
    SAVE_OPLINE();
41693
47
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41694
7
      value = ZVAL_UNDEFINED_OP1();
41695
7
    }
41696
47
    strict = EX_USES_STRICT_TYPES();
41697
47
    do {
41698
47
      if (EXPECTED(!strict)) {
41699
47
        zend_string *str;
41700
47
        zval tmp;
41701
41702
47
        if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
41703
12
          zend_error(E_DEPRECATED,
41704
12
            "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
41705
12
          ZVAL_LONG(EX_VAR(opline->result.var), 0);
41706
12
          if (UNEXPECTED(EG(exception))) {
41707
0
            HANDLE_EXCEPTION();
41708
0
          }
41709
12
          break;
41710
12
        }
41711
41712
35
        ZVAL_COPY(&tmp, value);
41713
35
        if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
41714
17
          ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
41715
17
          zval_ptr_dtor(&tmp);
41716
17
          break;
41717
17
        }
41718
18
        zval_ptr_dtor(&tmp);
41719
18
      }
41720
18
      if (!EG(exception)) {
41721
5
        zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
41722
5
      }
41723
18
      ZVAL_UNDEF(EX_VAR(opline->result.var));
41724
18
    } while (0);
41725
47
  }
41726
41727
47
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41728
47
}
41729
41730
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41731
4.56k
{
41732
4.56k
  USE_OPLINE
41733
4.56k
  zval *value;
41734
4.56k
  int result = 0;
41735
41736
4.56k
  value = EX_VAR(opline->op1.var);
41737
4.56k
  if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
41738
1.32k
type_check_resource:
41739
1.32k
    if (opline->extended_value != MAY_BE_RESOURCE
41740
1.32k
     || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
41741
1.32k
      result = 1;
41742
1.32k
    }
41743
3.58k
  } else if ((IS_CV & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
41744
355
    value = Z_REFVAL_P(value);
41745
355
    if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
41746
337
      goto type_check_resource;
41747
337
    }
41748
3.22k
  } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41749
1.39k
    result = ((1 << IS_NULL) & opline->extended_value) != 0;
41750
1.39k
    SAVE_OPLINE();
41751
1.39k
    ZVAL_UNDEFINED_OP1();
41752
1.39k
    if (UNEXPECTED(EG(exception))) {
41753
13
      ZVAL_UNDEF(EX_VAR(opline->result.var));
41754
13
      HANDLE_EXCEPTION();
41755
13
    }
41756
1.39k
  }
41757
4.55k
  if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41758
0
    SAVE_OPLINE();
41759
41760
0
    ZEND_VM_SMART_BRANCH(result, 1);
41761
4.55k
  } else {
41762
4.55k
    ZEND_VM_SMART_BRANCH(result, 0);
41763
4.55k
  }
41764
4.55k
}
41765
41766
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41767
827
{
41768
827
  uint32_t fetch_type;
41769
827
  zend_class_entry *called_scope, *scope;
41770
827
  USE_OPLINE
41771
41772
827
  if (IS_CV != IS_UNUSED) {
41773
827
    SAVE_OPLINE();
41774
827
    zval *op = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41775
827
    if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
41776
25
      ZVAL_DEREF(op);
41777
25
      if (Z_TYPE_P(op) != IS_OBJECT) {
41778
13
        zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
41779
13
        ZVAL_UNDEF(EX_VAR(opline->result.var));
41780
41781
13
        HANDLE_EXCEPTION();
41782
13
      }
41783
25
    }
41784
41785
814
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
41786
41787
814
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41788
814
  }
41789
41790
0
  fetch_type = opline->op1.num;
41791
0
  scope = EX(func)->op_array.scope;
41792
0
  if (UNEXPECTED(scope == NULL)) {
41793
0
    SAVE_OPLINE();
41794
0
    zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
41795
0
      fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
41796
0
      fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
41797
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41798
0
    HANDLE_EXCEPTION();
41799
0
  }
41800
41801
0
  switch (fetch_type) {
41802
0
    case ZEND_FETCH_CLASS_SELF:
41803
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
41804
0
      break;
41805
0
    case ZEND_FETCH_CLASS_PARENT:
41806
0
      if (UNEXPECTED(scope->parent == NULL)) {
41807
0
        SAVE_OPLINE();
41808
0
        zend_throw_error(NULL,
41809
0
          "Cannot use \"parent\" when current class scope has no parent");
41810
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
41811
0
        HANDLE_EXCEPTION();
41812
0
      }
41813
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
41814
0
      break;
41815
0
    case ZEND_FETCH_CLASS_STATIC:
41816
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
41817
0
        called_scope = Z_OBJCE(EX(This));
41818
0
      } else {
41819
0
        called_scope = Z_CE(EX(This));
41820
0
      }
41821
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
41822
0
      break;
41823
0
    EMPTY_SWITCH_DEFAULT_CASE()
41824
0
  }
41825
0
  ZEND_VM_NEXT_OPCODE();
41826
0
}
41827
41828
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41829
8.82k
{
41830
8.82k
  USE_OPLINE
41831
8.82k
  HashTable *ht;
41832
8.82k
  zval *value;
41833
8.82k
  zval *variable_ptr;
41834
41835
8.82k
  variable_ptr = EX_VAR(opline->op1.var);
41836
41837
8.82k
  SAVE_OPLINE();
41838
41839
8.82k
  ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
41840
8.82k
  if (!ht) {
41841
407
    ht = zend_array_dup(EX(func)->op_array.static_variables);
41842
407
    ZEND_MAP_PTR_SET(EX(func)->op_array.static_variables_ptr, ht);
41843
407
  }
41844
8.82k
  ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
41845
41846
8.82k
  value = (zval*)((char*)ht->arData + (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT|ZEND_BIND_EXPLICIT)));
41847
41848
8.82k
  if (opline->extended_value & ZEND_BIND_REF) {
41849
2.98k
    if (UNEXPECTED(!Z_ISREF_P(value))) {
41850
555
      zend_reference *ref = (zend_reference*)emalloc(sizeof(zend_reference));
41851
555
      GC_SET_REFCOUNT(ref, 2);
41852
555
      GC_TYPE_INFO(ref) = GC_REFERENCE;
41853
555
      if (opline->op2_type == IS_UNUSED) {
41854
336
        ZVAL_COPY_VALUE(&ref->val, value);
41855
336
      } else {
41856
219
        ZEND_ASSERT(!Z_REFCOUNTED_P(value));
41857
219
        ZVAL_COPY(&ref->val, get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R));
41858
219
        FREE_OP(opline->op2_type, opline->op2.var);
41859
219
      }
41860
555
      ref->sources.ptr = NULL;
41861
555
      Z_REF_P(value) = ref;
41862
555
      Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
41863
555
      i_zval_ptr_dtor(variable_ptr);
41864
555
      ZVAL_REF(variable_ptr, ref);
41865
2.43k
    } else {
41866
2.43k
      Z_ADDREF_P(value);
41867
2.43k
      i_zval_ptr_dtor(variable_ptr);
41868
2.43k
      ZVAL_REF(variable_ptr, Z_REF_P(value));
41869
2.43k
      if (opline->op2_type != IS_UNUSED) {
41870
109
        FREE_OP(opline->op2_type, opline->op2.var);
41871
109
      }
41872
2.43k
    }
41873
5.84k
  } else {
41874
5.84k
    i_zval_ptr_dtor(variable_ptr);
41875
5.84k
    ZVAL_COPY(variable_ptr, value);
41876
5.84k
  }
41877
41878
8.82k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41879
8.82k
}
41880
41881
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41882
637
{
41883
637
  USE_OPLINE
41884
637
  HashTable *ht;
41885
637
  zval *value;
41886
637
  zval *variable_ptr;
41887
41888
637
  variable_ptr = EX_VAR(opline->op1.var);
41889
41890
637
  ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
41891
637
  if (!ht) {
41892
310
    ZEND_VM_NEXT_OPCODE();
41893
310
  }
41894
327
  ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
41895
41896
327
  value = (zval*)((char*)ht->arData + opline->extended_value);
41897
327
  if (Z_TYPE_P(value) == IS_NULL) {
41898
97
    ZEND_VM_NEXT_OPCODE();
41899
230
  } else {
41900
230
    SAVE_OPLINE();
41901
230
    zval_ptr_dtor(variable_ptr);
41902
230
    ZEND_ASSERT(Z_TYPE_P(value) == IS_REFERENCE);
41903
230
    Z_ADDREF_P(value);
41904
230
    ZVAL_REF(variable_ptr, Z_REF_P(value));
41905
230
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 1);
41906
230
  }
41907
327
}
41908
41909
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41910
12.8k
{
41911
12.8k
  USE_OPLINE
41912
12.8k
  zval *var_ptr;
41913
41914
12.8k
  var_ptr = EX_VAR(opline->op1.var);
41915
12.8k
  Z_LVAL_P(var_ptr)++;
41916
12.8k
  if (UNEXPECTED(0)) {
41917
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41918
0
  }
41919
12.8k
  ZEND_VM_NEXT_OPCODE();
41920
12.8k
}
41921
41922
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41923
0
{
41924
0
  USE_OPLINE
41925
0
  zval *var_ptr;
41926
41927
0
  var_ptr = EX_VAR(opline->op1.var);
41928
0
  Z_LVAL_P(var_ptr)++;
41929
0
  if (UNEXPECTED(1)) {
41930
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41931
0
  }
41932
0
  ZEND_VM_NEXT_OPCODE();
41933
0
}
41934
41935
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41936
11
{
41937
11
  USE_OPLINE
41938
11
  zval *var_ptr;
41939
41940
11
  var_ptr = EX_VAR(opline->op1.var);
41941
11
  fast_long_increment_function(var_ptr);
41942
11
  if (UNEXPECTED(0)) {
41943
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41944
0
  }
41945
11
  ZEND_VM_NEXT_OPCODE();
41946
11
}
41947
41948
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41949
0
{
41950
0
  USE_OPLINE
41951
0
  zval *var_ptr;
41952
41953
0
  var_ptr = EX_VAR(opline->op1.var);
41954
0
  fast_long_increment_function(var_ptr);
41955
0
  if (UNEXPECTED(1)) {
41956
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41957
0
  }
41958
0
  ZEND_VM_NEXT_OPCODE();
41959
0
}
41960
41961
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41962
0
{
41963
0
  USE_OPLINE
41964
0
  zval *var_ptr;
41965
41966
0
  var_ptr = EX_VAR(opline->op1.var);
41967
0
  Z_LVAL_P(var_ptr)--;
41968
0
  if (UNEXPECTED(0)) {
41969
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41970
0
  }
41971
0
  ZEND_VM_NEXT_OPCODE();
41972
0
}
41973
41974
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41975
0
{
41976
0
  USE_OPLINE
41977
0
  zval *var_ptr;
41978
41979
0
  var_ptr = EX_VAR(opline->op1.var);
41980
0
  Z_LVAL_P(var_ptr)--;
41981
0
  if (UNEXPECTED(1)) {
41982
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41983
0
  }
41984
0
  ZEND_VM_NEXT_OPCODE();
41985
0
}
41986
41987
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41988
484
{
41989
484
  USE_OPLINE
41990
484
  zval *var_ptr;
41991
41992
484
  var_ptr = EX_VAR(opline->op1.var);
41993
484
  fast_long_decrement_function(var_ptr);
41994
484
  if (UNEXPECTED(0)) {
41995
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41996
0
  }
41997
484
  ZEND_VM_NEXT_OPCODE();
41998
484
}
41999
42000
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42001
0
{
42002
0
  USE_OPLINE
42003
0
  zval *var_ptr;
42004
42005
0
  var_ptr = EX_VAR(opline->op1.var);
42006
0
  fast_long_decrement_function(var_ptr);
42007
0
  if (UNEXPECTED(1)) {
42008
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
42009
0
  }
42010
0
  ZEND_VM_NEXT_OPCODE();
42011
0
}
42012
42013
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42014
255
{
42015
255
  USE_OPLINE
42016
255
  zval *var_ptr;
42017
42018
255
  var_ptr = EX_VAR(opline->op1.var);
42019
255
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
42020
255
  Z_LVAL_P(var_ptr)++;
42021
255
  ZEND_VM_NEXT_OPCODE();
42022
255
}
42023
42024
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42025
8
{
42026
8
  USE_OPLINE
42027
8
  zval *var_ptr;
42028
42029
8
  var_ptr = EX_VAR(opline->op1.var);
42030
8
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
42031
8
  fast_long_increment_function(var_ptr);
42032
8
  ZEND_VM_NEXT_OPCODE();
42033
8
}
42034
42035
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42036
747
{
42037
747
  USE_OPLINE
42038
747
  zval *var_ptr;
42039
42040
747
  var_ptr = EX_VAR(opline->op1.var);
42041
747
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
42042
747
  Z_LVAL_P(var_ptr)--;
42043
747
  ZEND_VM_NEXT_OPCODE();
42044
747
}
42045
42046
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42047
1.18k
{
42048
1.18k
  USE_OPLINE
42049
1.18k
  zval *var_ptr;
42050
42051
1.18k
  var_ptr = EX_VAR(opline->op1.var);
42052
1.18k
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
42053
1.18k
  fast_long_decrement_function(var_ptr);
42054
1.18k
  ZEND_VM_NEXT_OPCODE();
42055
1.18k
}
42056
42057
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42058
18.2k
{
42059
18.2k
  USE_OPLINE
42060
18.2k
  zval *varptr, *arg;
42061
42062
18.2k
  varptr = EX_VAR(opline->op1.var);
42063
18.2k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
42064
42065
18.2k
  if (IS_CV == IS_CV) {
42066
18.2k
    ZVAL_COPY(arg, varptr);
42067
18.2k
  } else /* if (IS_CV == IS_VAR) */ {
42068
0
    ZVAL_COPY_VALUE(arg, varptr);
42069
0
  }
42070
42071
18.2k
  ZEND_VM_NEXT_OPCODE();
42072
18.2k
}
42073
42074
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42075
1.86k
{
42076
1.86k
  USE_OPLINE
42077
1.86k
  zval *op1, *op2;
42078
42079
1.86k
  SAVE_OPLINE();
42080
1.86k
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42081
1.86k
  op2 = RT_CONSTANT(opline, opline->op2);
42082
1.86k
  div_function(EX_VAR(opline->result.var), op1, op2);
42083
42084
42085
1.86k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42086
1.86k
}
42087
42088
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42089
0
{
42090
0
  USE_OPLINE
42091
0
  zval *op1, *op2;
42092
42093
0
  SAVE_OPLINE();
42094
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42095
0
  op2 = RT_CONSTANT(opline, opline->op2);
42096
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
42097
42098
42099
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42100
0
}
42101
42102
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42103
1.54k
{
42104
1.54k
  USE_OPLINE
42105
1.54k
  zval *op1, *op2;
42106
42107
1.54k
  op1 = EX_VAR(opline->op1.var);
42108
1.54k
  op2 = RT_CONSTANT(opline, opline->op2);
42109
42110
1.54k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
42111
1.54k
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
42112
659
    zend_string *op1_str = Z_STR_P(op1);
42113
659
    zend_string *op2_str = Z_STR_P(op2);
42114
659
    zend_string *str;
42115
659
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
42116
42117
659
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
42118
1
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
42119
1
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
42120
1
      } else {
42121
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
42122
0
      }
42123
1
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42124
0
        zend_string_release_ex(op1_str, 0);
42125
0
      }
42126
658
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
42127
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
42128
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
42129
0
      } else {
42130
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
42131
0
      }
42132
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42133
0
        zend_string_release_ex(op2_str, 0);
42134
0
      }
42135
658
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
42136
658
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
42137
0
      size_t len = ZSTR_LEN(op1_str);
42138
42139
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
42140
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
42141
0
      }
42142
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
42143
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
42144
0
      GC_ADD_FLAGS(str, flags);
42145
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
42146
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42147
0
        zend_string_release_ex(op2_str, 0);
42148
0
      }
42149
658
    } else {
42150
658
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
42151
658
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
42152
658
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
42153
658
      GC_ADD_FLAGS(str, flags);
42154
658
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
42155
658
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42156
0
        zend_string_release_ex(op1_str, 0);
42157
0
      }
42158
658
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42159
0
        zend_string_release_ex(op2_str, 0);
42160
0
      }
42161
658
    }
42162
659
    ZEND_VM_NEXT_OPCODE();
42163
884
  } else {
42164
884
    SAVE_OPLINE();
42165
42166
884
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
42167
517
      op1 = ZVAL_UNDEFINED_OP1();
42168
517
    }
42169
884
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
42170
0
      op2 = ZVAL_UNDEFINED_OP2();
42171
0
    }
42172
884
    concat_function(EX_VAR(opline->result.var), op1, op2);
42173
42174
42175
884
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42176
884
  }
42177
1.54k
}
42178
42179
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42180
1.40k
{
42181
1.40k
  USE_OPLINE
42182
1.40k
  zval *op1, *op2;
42183
1.40k
  bool result;
42184
42185
1.40k
  SAVE_OPLINE();
42186
1.40k
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42187
1.40k
  op2 = RT_CONSTANT(opline, opline->op2);
42188
1.40k
  result = fast_is_identical_function(op1, op2);
42189
42190
42191
1.40k
  ZEND_VM_SMART_BRANCH(result, 1);
42192
1.40k
}
42193
42194
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42195
501
{
42196
501
  USE_OPLINE
42197
501
  zval *op1, *op2;
42198
501
  bool result;
42199
42200
501
  SAVE_OPLINE();
42201
501
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42202
501
  op2 = RT_CONSTANT(opline, opline->op2);
42203
501
  result = fast_is_not_identical_function(op1, op2);
42204
42205
42206
501
  ZEND_VM_SMART_BRANCH(result, 1);
42207
501
}
42208
42209
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42210
1.02k
{
42211
1.02k
  USE_OPLINE
42212
1.02k
  zval *op1, *op2;
42213
1.02k
  double d1, d2;
42214
42215
1.02k
  op1 = EX_VAR(opline->op1.var);
42216
1.02k
  op2 = RT_CONSTANT(opline, opline->op2);
42217
1.02k
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42218
    /* pass */
42219
1.02k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42220
224
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42221
221
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42222
239
is_equal_true:
42223
239
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
42224
239
      } else {
42225
70
is_equal_false:
42226
70
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
42227
70
      }
42228
221
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42229
2
      d1 = (double)Z_LVAL_P(op1);
42230
2
      d2 = Z_DVAL_P(op2);
42231
2
      goto is_equal_double;
42232
2
    }
42233
797
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42234
30
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42235
0
      d1 = Z_DVAL_P(op1);
42236
0
      d2 = Z_DVAL_P(op2);
42237
32
is_equal_double:
42238
32
      if (d1 == d2) {
42239
30
        goto is_equal_true;
42240
30
      } else {
42241
2
        goto is_equal_false;
42242
2
      }
42243
32
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42244
30
      d1 = Z_DVAL_P(op1);
42245
30
      d2 = (double)Z_LVAL_P(op2);
42246
30
      goto is_equal_double;
42247
30
    }
42248
767
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42249
147
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42250
56
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42251
56
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42252
0
        zval_ptr_dtor_str(op1);
42253
0
      }
42254
56
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42255
0
        zval_ptr_dtor_str(op2);
42256
0
      }
42257
56
      if (result) {
42258
0
        goto is_equal_true;
42259
56
      } else {
42260
56
        goto is_equal_false;
42261
56
      }
42262
56
    }
42263
147
  }
42264
1.02k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42265
1.02k
}
42266
42267
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42268
235k
{
42269
235k
  USE_OPLINE
42270
235k
  zval *op1, *op2;
42271
235k
  double d1, d2;
42272
42273
235k
  op1 = EX_VAR(opline->op1.var);
42274
235k
  op2 = RT_CONSTANT(opline, opline->op2);
42275
235k
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42276
    /* pass */
42277
235k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42278
1.64k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42279
1.64k
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42280
940
is_equal_true:
42281
940
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
42282
1.06k
      } else {
42283
1.75k
is_equal_false:
42284
1.75k
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
42285
1.75k
      }
42286
1.64k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42287
2
      d1 = (double)Z_LVAL_P(op1);
42288
2
      d2 = Z_DVAL_P(op2);
42289
2
      goto is_equal_double;
42290
2
    }
42291
233k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42292
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42293
0
      d1 = Z_DVAL_P(op1);
42294
0
      d2 = Z_DVAL_P(op2);
42295
2
is_equal_double:
42296
2
      if (d1 == d2) {
42297
0
        goto is_equal_true;
42298
2
      } else {
42299
2
        goto is_equal_false;
42300
2
      }
42301
2
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42302
0
      d1 = Z_DVAL_P(op1);
42303
0
      d2 = (double)Z_LVAL_P(op2);
42304
0
      goto is_equal_double;
42305
0
    }
42306
233k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42307
1.31k
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42308
1.04k
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42309
1.04k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42310
0
        zval_ptr_dtor_str(op1);
42311
0
      }
42312
1.04k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42313
0
        zval_ptr_dtor_str(op2);
42314
0
      }
42315
1.04k
      if (result) {
42316
361
        goto is_equal_true;
42317
685
      } else {
42318
685
        goto is_equal_false;
42319
685
      }
42320
1.04k
    }
42321
1.31k
  }
42322
235k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42323
235k
}
42324
42325
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42326
278
{
42327
278
  USE_OPLINE
42328
278
  zval *op1, *op2;
42329
278
  double d1, d2;
42330
42331
278
  op1 = EX_VAR(opline->op1.var);
42332
278
  op2 = RT_CONSTANT(opline, opline->op2);
42333
278
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42334
    /* pass */
42335
278
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42336
45
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42337
45
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42338
91
is_equal_true:
42339
91
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
42340
91
      } else {
42341
91
is_equal_false:
42342
91
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
42343
91
      }
42344
45
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42345
0
      d1 = (double)Z_LVAL_P(op1);
42346
0
      d2 = Z_DVAL_P(op2);
42347
0
      goto is_equal_double;
42348
0
    }
42349
233
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42350
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42351
0
      d1 = Z_DVAL_P(op1);
42352
0
      d2 = Z_DVAL_P(op2);
42353
0
is_equal_double:
42354
0
      if (d1 == d2) {
42355
0
        goto is_equal_true;
42356
0
      } else {
42357
0
        goto is_equal_false;
42358
0
      }
42359
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42360
0
      d1 = Z_DVAL_P(op1);
42361
0
      d2 = (double)Z_LVAL_P(op2);
42362
0
      goto is_equal_double;
42363
0
    }
42364
233
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42365
137
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42366
137
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42367
137
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42368
0
        zval_ptr_dtor_str(op1);
42369
0
      }
42370
137
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42371
0
        zval_ptr_dtor_str(op2);
42372
0
      }
42373
137
      if (result) {
42374
66
        goto is_equal_true;
42375
71
      } else {
42376
71
        goto is_equal_false;
42377
71
      }
42378
137
    }
42379
137
  }
42380
278
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42381
278
}
42382
42383
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42384
1.64k
{
42385
1.64k
  USE_OPLINE
42386
1.64k
  zval *op1, *op2;
42387
1.64k
  double d1, d2;
42388
42389
1.64k
  op1 = EX_VAR(opline->op1.var);
42390
1.64k
  op2 = RT_CONSTANT(opline, opline->op2);
42391
1.64k
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42392
    /* pass */
42393
1.64k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42394
357
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42395
313
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42396
470
is_not_equal_true:
42397
470
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
42398
470
      } else {
42399
30
is_not_equal_false:
42400
30
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
42401
30
      }
42402
313
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42403
44
      d1 = (double)Z_LVAL_P(op1);
42404
44
      d2 = Z_DVAL_P(op2);
42405
44
      goto is_not_equal_double;
42406
44
    }
42407
1.29k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42408
123
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42409
18
      d1 = Z_DVAL_P(op1);
42410
18
      d2 = Z_DVAL_P(op2);
42411
167
is_not_equal_double:
42412
167
      if (d1 != d2) {
42413
167
        goto is_not_equal_true;
42414
167
      } else {
42415
0
        goto is_not_equal_false;
42416
0
      }
42417
167
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42418
105
      d1 = Z_DVAL_P(op1);
42419
105
      d2 = (double)Z_LVAL_P(op2);
42420
105
      goto is_not_equal_double;
42421
105
    }
42422
1.16k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42423
20
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42424
20
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42425
20
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42426
0
        zval_ptr_dtor_str(op1);
42427
0
      }
42428
20
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42429
0
        zval_ptr_dtor_str(op2);
42430
0
      }
42431
20
      if (!result) {
42432
20
        goto is_not_equal_true;
42433
20
      } else {
42434
0
        goto is_not_equal_false;
42435
0
      }
42436
20
    }
42437
20
  }
42438
1.64k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42439
1.64k
}
42440
42441
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42442
486
{
42443
486
  USE_OPLINE
42444
486
  zval *op1, *op2;
42445
486
  double d1, d2;
42446
42447
486
  op1 = EX_VAR(opline->op1.var);
42448
486
  op2 = RT_CONSTANT(opline, opline->op2);
42449
486
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42450
    /* pass */
42451
486
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42452
99
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42453
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42454
44
is_not_equal_true:
42455
44
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
42456
44
      } else {
42457
257
is_not_equal_false:
42458
257
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
42459
257
      }
42460
99
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42461
21
      d1 = (double)Z_LVAL_P(op1);
42462
21
      d2 = Z_DVAL_P(op2);
42463
21
      goto is_not_equal_double;
42464
21
    }
42465
387
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42466
18
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42467
18
      d1 = Z_DVAL_P(op1);
42468
18
      d2 = Z_DVAL_P(op2);
42469
39
is_not_equal_double:
42470
39
      if (d1 != d2) {
42471
39
        goto is_not_equal_true;
42472
39
      } else {
42473
0
        goto is_not_equal_false;
42474
0
      }
42475
39
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42476
0
      d1 = Z_DVAL_P(op1);
42477
0
      d2 = (double)Z_LVAL_P(op2);
42478
0
      goto is_not_equal_double;
42479
0
    }
42480
369
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42481
262
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42482
262
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42483
262
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42484
0
        zval_ptr_dtor_str(op1);
42485
0
      }
42486
262
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42487
0
        zval_ptr_dtor_str(op2);
42488
0
      }
42489
262
      if (!result) {
42490
5
        goto is_not_equal_true;
42491
257
      } else {
42492
257
        goto is_not_equal_false;
42493
257
      }
42494
262
    }
42495
262
  }
42496
486
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42497
486
}
42498
42499
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42500
272
{
42501
272
  USE_OPLINE
42502
272
  zval *op1, *op2;
42503
272
  double d1, d2;
42504
42505
272
  op1 = EX_VAR(opline->op1.var);
42506
272
  op2 = RT_CONSTANT(opline, opline->op2);
42507
272
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42508
    /* pass */
42509
272
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42510
201
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42511
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42512
5
is_not_equal_true:
42513
5
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
42514
5
      } else {
42515
0
is_not_equal_false:
42516
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
42517
0
      }
42518
201
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42519
0
      d1 = (double)Z_LVAL_P(op1);
42520
0
      d2 = Z_DVAL_P(op2);
42521
0
      goto is_not_equal_double;
42522
0
    }
42523
201
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42524
30
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42525
0
      d1 = Z_DVAL_P(op1);
42526
0
      d2 = Z_DVAL_P(op2);
42527
0
is_not_equal_double:
42528
0
      if (d1 != d2) {
42529
0
        goto is_not_equal_true;
42530
0
      } else {
42531
0
        goto is_not_equal_false;
42532
0
      }
42533
30
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42534
0
      d1 = Z_DVAL_P(op1);
42535
0
      d2 = (double)Z_LVAL_P(op2);
42536
0
      goto is_not_equal_double;
42537
0
    }
42538
41
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42539
5
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42540
5
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42541
5
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42542
0
        zval_ptr_dtor_str(op1);
42543
0
      }
42544
5
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42545
0
        zval_ptr_dtor_str(op2);
42546
0
      }
42547
5
      if (!result) {
42548
5
        goto is_not_equal_true;
42549
5
      } else {
42550
0
        goto is_not_equal_false;
42551
0
      }
42552
5
    }
42553
5
  }
42554
272
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42555
272
}
42556
42557
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42558
0
{
42559
0
  USE_OPLINE
42560
0
  zval *op1, *op2;
42561
42562
0
  SAVE_OPLINE();
42563
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42564
0
  op2 = RT_CONSTANT(opline, opline->op2);
42565
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
42566
42567
42568
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42569
0
}
42570
42571
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42572
0
{
42573
0
  USE_OPLINE
42574
0
  zval *op1, *op2;
42575
42576
0
  SAVE_OPLINE();
42577
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42578
0
  op2 = RT_CONSTANT(opline, opline->op2);
42579
0
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
42580
42581
42582
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42583
0
}
42584
42585
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42586
662
{
42587
662
  USE_OPLINE
42588
662
  zval *object;
42589
662
  zval *property;
42590
662
  zval *value;
42591
662
  zval *zptr;
42592
662
  void *_cache_slot[3] = {0};
42593
662
  void **cache_slot;
42594
662
  zend_property_info *prop_info;
42595
662
  zend_object *zobj;
42596
662
  zend_string *name, *tmp_name;
42597
42598
662
  SAVE_OPLINE();
42599
662
  object = EX_VAR(opline->op1.var);
42600
662
  property = RT_CONSTANT(opline, opline->op2);
42601
42602
662
  do {
42603
662
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
42604
42605
662
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42606
198
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42607
150
        object = Z_REFVAL_P(object);
42608
150
        goto assign_op_object;
42609
150
      }
42610
48
      if (IS_CV == IS_CV
42611
48
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42612
11
        ZVAL_UNDEFINED_OP1();
42613
11
      }
42614
48
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42615
48
      break;
42616
198
    }
42617
42618
614
assign_op_object:
42619
    /* here we are sure we are dealing with an object */
42620
614
    zobj = Z_OBJ_P(object);
42621
614
    if (IS_CONST == IS_CONST) {
42622
614
      name = Z_STR_P(property);
42623
614
    } else {
42624
0
      name = zval_try_get_tmp_string(property, &tmp_name);
42625
0
      if (UNEXPECTED(!name)) {
42626
0
        UNDEF_RESULT();
42627
0
        break;
42628
0
      }
42629
0
    }
42630
614
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
42631
614
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42632
442
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42633
37
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42634
14
          ZVAL_NULL(EX_VAR(opline->result.var));
42635
14
        }
42636
405
      } else {
42637
405
        zend_reference *ref;
42638
42639
405
        do {
42640
405
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
42641
47
            ref = Z_REF_P(zptr);
42642
47
            zptr = Z_REFVAL_P(zptr);
42643
47
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42644
42
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42645
42
              break;
42646
42
            }
42647
47
          }
42648
42649
363
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
42650
363
          if (prop_info) {
42651
            /* special case for typed properties */
42652
104
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
42653
259
          } else {
42654
259
            zend_binary_op(zptr, zptr, value OPLINE_CC);
42655
259
          }
42656
363
        } while (0);
42657
42658
405
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42659
147
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
42660
147
        }
42661
405
      }
42662
442
    } else {
42663
172
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
42664
172
    }
42665
614
    if (IS_CONST != IS_CONST) {
42666
0
      zend_tmp_string_release(tmp_name);
42667
0
    }
42668
614
  } while (0);
42669
42670
662
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42671
42672
42673
  /* assign_obj has two opcodes! */
42674
662
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
42675
662
}
42676
42677
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
42678
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42679
1.05k
{
42680
1.05k
  USE_OPLINE
42681
1.05k
  zval *var_ptr;
42682
1.05k
  zval *value, *container, *dim;
42683
1.05k
  HashTable *ht;
42684
42685
1.05k
  SAVE_OPLINE();
42686
1.05k
  container = EX_VAR(opline->op1.var);
42687
42688
1.05k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42689
883
assign_dim_op_array:
42690
883
    SEPARATE_ARRAY(container);
42691
883
    ht = Z_ARRVAL_P(container);
42692
980
assign_dim_op_new_array:
42693
980
    dim = RT_CONSTANT(opline, opline->op2);
42694
980
    if (IS_CONST == IS_UNUSED) {
42695
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
42696
0
      if (UNEXPECTED(!var_ptr)) {
42697
0
        zend_cannot_add_element();
42698
0
        goto assign_dim_op_ret_null;
42699
0
      }
42700
980
    } else {
42701
980
      if (IS_CONST == IS_CONST) {
42702
980
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
42703
980
      } else {
42704
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
42705
0
      }
42706
980
      if (UNEXPECTED(!var_ptr)) {
42707
79
        goto assign_dim_op_ret_null;
42708
79
      }
42709
980
    }
42710
42711
901
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
42712
42713
901
    do {
42714
901
      if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
42715
60
        zend_reference *ref = Z_REF_P(var_ptr);
42716
60
        var_ptr = Z_REFVAL_P(var_ptr);
42717
60
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42718
60
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42719
60
          break;
42720
60
        }
42721
60
      }
42722
841
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
42723
841
    } while (0);
42724
42725
901
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42726
119
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
42727
119
    }
42728
901
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42729
901
  } else {
42730
178
    if (EXPECTED(Z_ISREF_P(container))) {
42731
51
      container = Z_REFVAL_P(container);
42732
51
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42733
8
        goto assign_dim_op_array;
42734
8
      }
42735
51
    }
42736
42737
170
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
42738
48
      zend_object *obj = Z_OBJ_P(container);
42739
42740
48
      dim = RT_CONSTANT(opline, opline->op2);
42741
48
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42742
0
        dim++;
42743
0
      }
42744
48
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
42745
122
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
42746
97
      uint8_t old_type;
42747
42748
97
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
42749
41
        ZVAL_UNDEFINED_OP1();
42750
41
      }
42751
97
      ht = zend_new_array(8);
42752
97
      old_type = Z_TYPE_P(container);
42753
97
      ZVAL_ARR(container, ht);
42754
97
      if (UNEXPECTED(old_type == IS_FALSE)) {
42755
13
        GC_ADDREF(ht);
42756
13
        zend_false_to_array_deprecated();
42757
13
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
42758
0
          zend_array_destroy(ht);
42759
0
          goto assign_dim_op_ret_null;
42760
0
        }
42761
13
      }
42762
97
      goto assign_dim_op_new_array;
42763
97
    } else {
42764
25
      dim = RT_CONSTANT(opline, opline->op2);
42765
25
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
42766
104
assign_dim_op_ret_null:
42767
104
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42768
104
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42769
30
        ZVAL_NULL(EX_VAR(opline->result.var));
42770
30
      }
42771
104
    }
42772
170
  }
42773
42774
42775
1.05k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
42776
1.05k
}
42777
42778
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42779
5.31k
{
42780
5.31k
  USE_OPLINE
42781
5.31k
  zval *var_ptr;
42782
5.31k
  zval *value;
42783
42784
5.31k
  SAVE_OPLINE();
42785
5.31k
  value = RT_CONSTANT(opline, opline->op2);
42786
5.31k
  var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
42787
42788
5.31k
  do {
42789
5.31k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
42790
1.09k
      zend_reference *ref = Z_REF_P(var_ptr);
42791
1.09k
      var_ptr = Z_REFVAL_P(var_ptr);
42792
1.09k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42793
96
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42794
96
        break;
42795
96
      }
42796
1.09k
    }
42797
5.22k
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
42798
5.22k
  } while (0);
42799
42800
5.31k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42801
756
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
42802
756
  }
42803
42804
42805
5.31k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42806
5.31k
}
42807
42808
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42809
928
{
42810
928
  USE_OPLINE
42811
928
  zval *object;
42812
928
  zval *property;
42813
928
  zval *zptr;
42814
928
  void *_cache_slot[3] = {0};
42815
928
  void **cache_slot;
42816
928
  zend_property_info *prop_info;
42817
928
  zend_object *zobj;
42818
928
  zend_string *name, *tmp_name;
42819
42820
928
  SAVE_OPLINE();
42821
928
  object = EX_VAR(opline->op1.var);
42822
928
  property = RT_CONSTANT(opline, opline->op2);
42823
42824
928
  do {
42825
928
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42826
77
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42827
51
        object = Z_REFVAL_P(object);
42828
51
        goto pre_incdec_object;
42829
51
      }
42830
26
      if (IS_CV == IS_CV
42831
26
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42832
11
        ZVAL_UNDEFINED_OP1();
42833
11
      }
42834
26
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42835
26
      break;
42836
77
    }
42837
42838
902
pre_incdec_object:
42839
    /* here we are sure we are dealing with an object */
42840
902
    zobj = Z_OBJ_P(object);
42841
902
    if (IS_CONST == IS_CONST) {
42842
902
      name = Z_STR_P(property);
42843
902
    } else {
42844
0
      name = zval_try_get_tmp_string(property, &tmp_name);
42845
0
      if (UNEXPECTED(!name)) {
42846
0
        UNDEF_RESULT();
42847
0
        break;
42848
0
      }
42849
0
    }
42850
902
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
42851
902
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42852
735
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42853
22
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42854
17
          ZVAL_NULL(EX_VAR(opline->result.var));
42855
17
        }
42856
713
      } else {
42857
713
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
42858
713
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
42859
713
      }
42860
735
    } else {
42861
167
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
42862
167
    }
42863
902
    if (IS_CONST != IS_CONST) {
42864
0
      zend_tmp_string_release(tmp_name);
42865
0
    }
42866
902
  } while (0);
42867
42868
42869
928
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42870
928
}
42871
42872
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42873
460
{
42874
460
  USE_OPLINE
42875
460
  zval *object;
42876
460
  zval *property;
42877
460
  zval *zptr;
42878
460
  void *_cache_slot[3] = {0};
42879
460
  void **cache_slot;
42880
460
  zend_property_info *prop_info;
42881
460
  zend_object *zobj;
42882
460
  zend_string *name, *tmp_name;
42883
42884
460
  SAVE_OPLINE();
42885
460
  object = EX_VAR(opline->op1.var);
42886
460
  property = RT_CONSTANT(opline, opline->op2);
42887
42888
460
  do {
42889
460
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42890
27
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42891
0
        object = Z_REFVAL_P(object);
42892
0
        goto post_incdec_object;
42893
0
      }
42894
27
      if (IS_CV == IS_CV
42895
27
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42896
22
        ZVAL_UNDEFINED_OP1();
42897
22
      }
42898
27
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42899
27
      break;
42900
27
    }
42901
42902
433
post_incdec_object:
42903
    /* here we are sure we are dealing with an object */
42904
433
    zobj = Z_OBJ_P(object);
42905
433
    if (IS_CONST == IS_CONST) {
42906
433
      name = Z_STR_P(property);
42907
433
    } else {
42908
0
      name = zval_try_get_tmp_string(property, &tmp_name);
42909
0
      if (UNEXPECTED(!name)) {
42910
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
42911
0
        break;
42912
0
      }
42913
0
    }
42914
433
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
42915
433
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42916
418
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42917
58
        ZVAL_NULL(EX_VAR(opline->result.var));
42918
360
      } else {
42919
360
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
42920
360
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
42921
360
      }
42922
418
    } else {
42923
15
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
42924
15
    }
42925
433
    if (IS_CONST != IS_CONST) {
42926
0
      zend_tmp_string_release(tmp_name);
42927
0
    }
42928
433
  } while (0);
42929
42930
42931
460
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42932
460
}
42933
42934
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42935
5.43k
{
42936
5.43k
  USE_OPLINE
42937
5.43k
  zval *container, *dim, *value;
42938
42939
5.43k
  SAVE_OPLINE();
42940
5.43k
  container = EX_VAR(opline->op1.var);
42941
5.43k
  dim = RT_CONSTANT(opline, opline->op2);
42942
5.43k
  if (IS_CV != IS_CONST) {
42943
5.43k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42944
3.63k
fetch_dim_r_array:
42945
3.63k
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
42946
3.63k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42947
3.63k
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
42948
1.17k
      container = Z_REFVAL_P(container);
42949
1.17k
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42950
1.14k
        goto fetch_dim_r_array;
42951
1.14k
      } else {
42952
27
        goto fetch_dim_r_slow;
42953
27
      }
42954
1.76k
    } else {
42955
1.79k
fetch_dim_r_slow:
42956
1.79k
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42957
28
        dim++;
42958
28
      }
42959
1.79k
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
42960
1.79k
    }
42961
5.43k
  } else {
42962
0
    zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42963
0
  }
42964
42965
42966
5.43k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42967
5.43k
}
42968
42969
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42970
5.99k
{
42971
5.99k
  USE_OPLINE
42972
5.99k
  zval *container;
42973
42974
5.99k
  SAVE_OPLINE();
42975
5.99k
  container = EX_VAR(opline->op1.var);
42976
5.99k
  zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42977
42978
5.99k
  if (IS_CV == IS_VAR) {
42979
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42980
0
  }
42981
5.99k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42982
5.99k
}
42983
42984
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42985
305
{
42986
305
  USE_OPLINE
42987
305
  zval *container;
42988
42989
305
  SAVE_OPLINE();
42990
305
  container = EX_VAR(opline->op1.var);
42991
305
  zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42992
42993
305
  if (IS_CV == IS_VAR) {
42994
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42995
0
  }
42996
305
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42997
305
}
42998
42999
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43000
870
{
43001
870
  USE_OPLINE
43002
870
  zval *container;
43003
43004
870
  SAVE_OPLINE();
43005
870
  container = EX_VAR(opline->op1.var);
43006
870
  zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
43007
43008
43009
870
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43010
870
}
43011
43012
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43013
195
{
43014
#if 0
43015
  USE_OPLINE
43016
#endif
43017
43018
195
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
43019
32
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
43020
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43021
0
    }
43022
32
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43023
163
  } else {
43024
163
    if (IS_CONST == IS_UNUSED) {
43025
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43026
0
    }
43027
163
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43028
163
  }
43029
195
}
43030
43031
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43032
102
{
43033
102
  USE_OPLINE
43034
102
  zval *container;
43035
43036
102
  SAVE_OPLINE();
43037
102
  container = EX_VAR(opline->op1.var);
43038
102
  zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
43039
43040
102
  if (IS_CV == IS_VAR) {
43041
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43042
0
  }
43043
102
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43044
102
}
43045
43046
static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43047
35.1k
{
43048
35.1k
  USE_OPLINE
43049
35.1k
  zval *container;
43050
35.1k
  void **cache_slot = NULL;
43051
43052
35.1k
  SAVE_OPLINE();
43053
35.1k
  container = EX_VAR(opline->op1.var);
43054
43055
35.1k
  if (IS_CV == IS_CONST ||
43056
35.1k
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
43057
25.6k
    do {
43058
25.6k
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
43059
899
        container = Z_REFVAL_P(container);
43060
899
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
43061
683
          break;
43062
683
        }
43063
899
      }
43064
24.9k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
43065
23.9k
        ZVAL_UNDEFINED_OP1();
43066
23.9k
      }
43067
24.9k
      zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
43068
24.9k
      ZVAL_NULL(EX_VAR(opline->result.var));
43069
24.9k
      goto fetch_obj_r_finish;
43070
25.6k
    } while (0);
43071
25.6k
  }
43072
43073
  /* here we are sure we are dealing with an object */
43074
10.2k
  do {
43075
10.2k
    zend_object *zobj = Z_OBJ_P(container);
43076
10.2k
    zend_string *name, *tmp_name;
43077
10.2k
    zval *retval;
43078
43079
10.2k
    if (IS_CONST == IS_CONST) {
43080
10.2k
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
43081
43082
10.2k
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
43083
2.10k
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43084
43085
2.10k
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43086
1.28k
fetch_obj_r_simple:
43087
1.28k
          retval = OBJ_PROP(zobj, prop_offset);
43088
1.28k
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
43089
1.16k
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43090
0
              goto fetch_obj_r_copy;
43091
1.16k
            } else {
43092
1.32k
fetch_obj_r_fast_copy:
43093
1.32k
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43094
1.32k
              ZEND_VM_NEXT_OPCODE();
43095
1.32k
            }
43096
1.16k
          }
43097
1.28k
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
43098
83
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43099
83
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
43100
5
            prop_offset = prop_info->offset;
43101
5
            goto fetch_obj_r_simple;
43102
78
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
43103
35
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
43104
35
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
43105
35
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
43106
43107
35
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
43108
35
            if (IS_CV & IS_CV) {
43109
35
              GC_ADDREF(zobj);
43110
35
            }
43111
35
            if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
43112
35
              call_info |= ZEND_CALL_RELEASE_THIS;
43113
35
            }
43114
35
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
43115
35
            call->prev_execute_data = execute_data;
43116
35
            call->call = NULL;
43117
35
            call->return_value = EX_VAR(opline->result.var);
43118
35
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
43119
43120
35
            execute_data = call;
43121
35
            EG(current_execute_data) = execute_data;
43122
35
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
43123
43124
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
43125
            opline = hook->op_array.opcodes;
43126
#else
43127
35
            EX(opline) = hook->op_array.opcodes;
43128
35
#endif
43129
35
            LOAD_OPLINE_EX();
43130
43131
43132
35
            ZEND_VM_ENTER_EX();
43133
35
          }
43134
          /* Fall through to read_property for hooks. */
43135
741
        } else if (EXPECTED(zobj->properties != NULL)) {
43136
461
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
43137
461
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43138
461
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
43139
159
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
43140
43141
159
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
43142
159
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
43143
43144
159
              if (EXPECTED(p->key == name) ||
43145
159
                  (EXPECTED(p->h == ZSTR_H(name)) &&
43146
0
                   EXPECTED(p->key != NULL) &&
43147
159
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
43148
159
                retval = &p->val;
43149
159
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43150
0
                  goto fetch_obj_r_copy;
43151
159
                } else {
43152
159
                  goto fetch_obj_r_fast_copy;
43153
159
                }
43154
159
              }
43155
159
            }
43156
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
43157
0
          }
43158
302
          retval = zend_hash_find_known_hash(zobj->properties, name);
43159
302
          if (EXPECTED(retval)) {
43160
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
43161
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
43162
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43163
0
              goto fetch_obj_r_copy;
43164
0
            } else {
43165
0
              goto fetch_obj_r_fast_copy;
43166
0
            }
43167
0
          }
43168
302
        }
43169
2.10k
      }
43170
8.84k
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43171
8.84k
    } else {
43172
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43173
0
      if (UNEXPECTED(!name)) {
43174
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
43175
0
        break;
43176
0
      }
43177
0
    }
43178
43179
8.84k
#if ZEND_DEBUG
43180
    /* For non-standard object handlers, verify a declared property type in debug builds.
43181
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
43182
8.84k
    zend_property_info *prop_info = NULL;
43183
8.84k
    if (zobj->handlers->read_property != zend_std_read_property) {
43184
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
43185
0
    }
43186
8.84k
#endif
43187
8.84k
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
43188
8.84k
#if ZEND_DEBUG
43189
8.84k
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
43190
8.84k
        && ZEND_TYPE_IS_SET(prop_info->type)) {
43191
0
      ZVAL_OPT_DEREF(retval);
43192
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
43193
0
    }
43194
8.84k
#endif
43195
43196
8.84k
    if (IS_CONST != IS_CONST) {
43197
0
      zend_tmp_string_release(tmp_name);
43198
0
    }
43199
43200
8.84k
    if (retval != EX_VAR(opline->result.var)) {
43201
7.91k
fetch_obj_r_copy:
43202
7.91k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43203
7.91k
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
43204
96
      zend_unwrap_reference(retval);
43205
96
    }
43206
8.84k
  } while (0);
43207
43208
33.8k
fetch_obj_r_finish:
43209
43210
43211
33.8k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43212
33.8k
}
43213
43214
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43215
35.1k
{
43216
35.1k
  ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43217
35.1k
}
43218
43219
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43220
2.05k
{
43221
2.05k
  USE_OPLINE
43222
2.05k
  zval *property, *container, *result;
43223
43224
2.05k
  SAVE_OPLINE();
43225
43226
2.05k
  container = EX_VAR(opline->op1.var);
43227
2.05k
  property = RT_CONSTANT(opline, opline->op2);
43228
2.05k
  result = EX_VAR(opline->result.var);
43229
2.05k
  zend_fetch_property_address(
43230
2.05k
    result, container, IS_CV, property, IS_CONST,
43231
2.05k
    ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
43232
2.05k
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
43233
43234
2.05k
  if (IS_CV == IS_VAR) {
43235
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43236
0
  }
43237
2.05k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43238
2.05k
}
43239
43240
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43241
55
{
43242
55
  USE_OPLINE
43243
55
  zval *property, *container, *result;
43244
43245
55
  SAVE_OPLINE();
43246
55
  container = EX_VAR(opline->op1.var);
43247
55
  property = RT_CONSTANT(opline, opline->op2);
43248
55
  result = EX_VAR(opline->result.var);
43249
55
  zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
43250
43251
55
  if (IS_CV == IS_VAR) {
43252
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43253
0
  }
43254
55
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43255
55
}
43256
43257
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43258
382
{
43259
382
  USE_OPLINE
43260
382
  zval *container;
43261
382
  void **cache_slot = NULL;
43262
43263
382
  SAVE_OPLINE();
43264
382
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
43265
43266
382
  if (IS_CV == IS_CONST ||
43267
382
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
43268
33
    do {
43269
33
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
43270
0
        container = Z_REFVAL_P(container);
43271
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
43272
0
          break;
43273
0
        }
43274
0
      }
43275
33
      if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
43276
0
        ZVAL_UNDEFINED_OP2();
43277
0
      }
43278
33
      ZVAL_NULL(EX_VAR(opline->result.var));
43279
33
      goto fetch_obj_is_finish;
43280
33
    } while (0);
43281
33
  }
43282
43283
  /* here we are sure we are dealing with an object */
43284
349
  do {
43285
349
    zend_object *zobj = Z_OBJ_P(container);
43286
349
    zend_string *name, *tmp_name;
43287
349
    zval *retval;
43288
43289
349
    if (IS_CONST == IS_CONST) {
43290
349
      cache_slot = CACHE_ADDR(opline->extended_value);
43291
43292
349
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
43293
73
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43294
43295
73
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43296
20
fetch_obj_is_simple:
43297
20
          retval = OBJ_PROP(zobj, prop_offset);
43298
20
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
43299
3
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43300
0
              goto fetch_obj_is_copy;
43301
3
            } else {
43302
42
fetch_obj_is_fast_copy:
43303
42
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43304
42
              ZEND_VM_NEXT_OPCODE();
43305
42
            }
43306
3
          }
43307
53
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
43308
5
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
43309
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43310
0
            prop_offset = prop_info->offset;
43311
0
            goto fetch_obj_is_simple;
43312
0
          }
43313
          /* Fall through to read_property for hooks. */
43314
48
        } else if (EXPECTED(zobj->properties != NULL)) {
43315
46
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
43316
46
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43317
46
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
43318
39
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
43319
43320
39
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
43321
39
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
43322
43323
39
              if (EXPECTED(p->key == name) ||
43324
39
                  (EXPECTED(p->h == ZSTR_H(name)) &&
43325
5
                   EXPECTED(p->key != NULL) &&
43326
34
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
43327
34
                retval = &p->val;
43328
34
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43329
0
                  goto fetch_obj_is_copy;
43330
34
                } else {
43331
34
                  goto fetch_obj_is_fast_copy;
43332
34
                }
43333
34
              }
43334
39
            }
43335
5
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
43336
5
          }
43337
12
          retval = zend_hash_find_known_hash(zobj->properties, name);
43338
12
          if (EXPECTED(retval)) {
43339
5
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
43340
5
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
43341
5
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43342
0
              goto fetch_obj_is_copy;
43343
5
            } else {
43344
5
              goto fetch_obj_is_fast_copy;
43345
5
            }
43346
5
          }
43347
12
        }
43348
73
      }
43349
307
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43350
307
    } else {
43351
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43352
0
      if (UNEXPECTED(!name)) {
43353
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
43354
0
        break;
43355
0
      }
43356
0
    }
43357
43358
307
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
43359
43360
307
    if (IS_CONST != IS_CONST) {
43361
0
      zend_tmp_string_release(tmp_name);
43362
0
    }
43363
43364
307
    if (retval != EX_VAR(opline->result.var)) {
43365
271
fetch_obj_is_copy:
43366
271
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43367
271
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
43368
21
      zend_unwrap_reference(retval);
43369
21
    }
43370
307
  } while (0);
43371
43372
340
fetch_obj_is_finish:
43373
43374
43375
340
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43376
340
}
43377
43378
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43379
80
{
43380
#if 0
43381
  USE_OPLINE
43382
#endif
43383
43384
80
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
43385
    /* Behave like FETCH_OBJ_W */
43386
17
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
43387
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43388
0
    }
43389
17
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43390
63
  } else {
43391
63
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43392
63
  }
43393
80
}
43394
43395
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43396
109
{
43397
109
  USE_OPLINE
43398
109
  zval *container, *property, *result;
43399
43400
109
  SAVE_OPLINE();
43401
109
  container = EX_VAR(opline->op1.var);
43402
109
  property = RT_CONSTANT(opline, opline->op2);
43403
109
  result = EX_VAR(opline->result.var);
43404
109
  zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
43405
43406
109
  if (IS_CV == IS_VAR) {
43407
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43408
0
  }
43409
109
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43410
109
}
43411
43412
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43413
4.80k
{
43414
4.80k
  USE_OPLINE
43415
4.80k
  zval *object, *value, tmp;
43416
4.80k
  zend_object *zobj;
43417
4.80k
  zend_string *name, *tmp_name;
43418
4.80k
  zend_refcounted *garbage = NULL;
43419
43420
4.80k
  SAVE_OPLINE();
43421
4.80k
  object = EX_VAR(opline->op1.var);
43422
4.80k
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
43423
43424
4.80k
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43425
632
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43426
580
      object = Z_REFVAL_P(object);
43427
580
      goto assign_object;
43428
580
    }
43429
52
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43430
52
    value = &EG(uninitialized_zval);
43431
52
    goto free_and_exit_assign_obj;
43432
632
  }
43433
43434
4.75k
assign_object:
43435
4.75k
  zobj = Z_OBJ_P(object);
43436
4.75k
  if (IS_CONST == IS_CONST) {
43437
4.75k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43438
1.44k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
43439
1.44k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43440
1.44k
      zval *property_val;
43441
1.44k
      zend_property_info *prop_info;
43442
43443
1.44k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43444
243
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43445
43446
243
assign_obj_simple:
43447
243
        property_val = OBJ_PROP(zobj, prop_offset);
43448
243
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
43449
194
          if (prop_info != NULL) {
43450
107
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43451
107
            goto free_and_exit_assign_obj;
43452
107
          } else {
43453
492
fast_assign_obj:
43454
492
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43455
492
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43456
168
              ZVAL_COPY(EX_VAR(opline->result.var), value);
43457
168
            }
43458
492
            goto exit_assign_obj;
43459
87
          }
43460
194
        }
43461
1.20k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43462
1.17k
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43463
1.17k
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43464
15
          zobj = zend_lazy_object_init(zobj);
43465
15
          if (!zobj) {
43466
5
            value = &EG(uninitialized_zval);
43467
5
            goto free_and_exit_assign_obj;
43468
5
          }
43469
15
        }
43470
1.16k
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43471
936
          rebuild_object_properties_internal(zobj);
43472
936
        }
43473
1.16k
        if (EXPECTED(zobj->properties != NULL)) {
43474
1.15k
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43475
101
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43476
101
              GC_DELREF(zobj->properties);
43477
101
            }
43478
101
            zobj->properties = zend_array_dup(zobj->properties);
43479
101
          }
43480
1.15k
          property_val = zend_hash_find_known_hash(zobj->properties, name);
43481
1.15k
          if (property_val) {
43482
405
            goto fast_assign_obj;
43483
405
          }
43484
1.15k
        }
43485
43486
761
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43487
709
          if (IS_CONST == IS_CONST) {
43488
709
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43489
0
              Z_ADDREF_P(value);
43490
0
            }
43491
709
          } else if (IS_CONST != IS_TMP_VAR) {
43492
0
            if (Z_ISREF_P(value)) {
43493
0
              if (IS_CONST == IS_VAR) {
43494
0
                zend_reference *ref = Z_REF_P(value);
43495
0
                if (GC_DELREF(ref) == 0) {
43496
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43497
0
                  efree_size(ref, sizeof(zend_reference));
43498
0
                  value = &tmp;
43499
0
                } else {
43500
0
                  value = Z_REFVAL_P(value);
43501
0
                  Z_TRY_ADDREF_P(value);
43502
0
                }
43503
0
              } else {
43504
0
                value = Z_REFVAL_P(value);
43505
0
                Z_TRY_ADDREF_P(value);
43506
0
              }
43507
0
            } else if (IS_CONST == IS_CV) {
43508
0
              Z_TRY_ADDREF_P(value);
43509
0
            }
43510
0
          }
43511
709
          zend_hash_add_new(zobj->properties, name, value);
43512
709
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43513
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
43514
0
          }
43515
709
          goto exit_assign_obj;
43516
709
        }
43517
761
      } else {
43518
31
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43519
31
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43520
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
43521
0
          prop_offset = prop_info->offset;
43522
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43523
0
            prop_info = NULL;
43524
0
          }
43525
0
          goto assign_obj_simple;
43526
0
        }
43527
        /* Fall through to write_property for hooks. */
43528
31
      }
43529
1.44k
    }
43530
3.43k
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43531
3.43k
  } else {
43532
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43533
0
    if (UNEXPECTED(!name)) {
43534
43535
0
      UNDEF_RESULT();
43536
0
      goto exit_assign_obj;
43537
0
    }
43538
0
  }
43539
43540
3.43k
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
43541
0
    ZVAL_DEREF(value);
43542
0
  }
43543
43544
3.43k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43545
43546
3.43k
  if (IS_CONST != IS_CONST) {
43547
0
    zend_tmp_string_release(tmp_name);
43548
0
  }
43549
43550
3.59k
free_and_exit_assign_obj:
43551
3.59k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43552
263
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43553
263
  }
43554
43555
4.79k
exit_assign_obj:
43556
4.79k
  if (garbage) {
43557
74
    GC_DTOR_NO_REF(garbage);
43558
74
  }
43559
43560
43561
  /* assign_obj has two opcodes! */
43562
4.79k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
43563
4.79k
}
43564
43565
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43566
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43567
1.26k
{
43568
1.26k
  USE_OPLINE
43569
1.26k
  zval *object, *value, tmp;
43570
1.26k
  zend_object *zobj;
43571
1.26k
  zend_string *name, *tmp_name;
43572
1.26k
  zend_refcounted *garbage = NULL;
43573
43574
1.26k
  SAVE_OPLINE();
43575
1.26k
  object = EX_VAR(opline->op1.var);
43576
1.26k
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
43577
43578
1.26k
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43579
667
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43580
644
      object = Z_REFVAL_P(object);
43581
644
      goto assign_object;
43582
644
    }
43583
23
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43584
23
    value = &EG(uninitialized_zval);
43585
23
    goto free_and_exit_assign_obj;
43586
667
  }
43587
43588
1.24k
assign_object:
43589
1.24k
  zobj = Z_OBJ_P(object);
43590
1.24k
  if (IS_CONST == IS_CONST) {
43591
1.24k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43592
847
      void **cache_slot = CACHE_ADDR(opline->extended_value);
43593
847
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43594
847
      zval *property_val;
43595
847
      zend_property_info *prop_info;
43596
43597
847
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43598
383
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43599
43600
383
assign_obj_simple:
43601
383
        property_val = OBJ_PROP(zobj, prop_offset);
43602
383
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
43603
383
          if (prop_info != NULL) {
43604
330
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43605
330
            goto free_and_exit_assign_obj;
43606
330
          } else {
43607
129
fast_assign_obj:
43608
129
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
43609
129
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43610
72
              ZVAL_COPY(EX_VAR(opline->result.var), value);
43611
72
            }
43612
129
            goto exit_assign_obj;
43613
53
          }
43614
383
        }
43615
464
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43616
464
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43617
464
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43618
0
          zobj = zend_lazy_object_init(zobj);
43619
0
          if (!zobj) {
43620
0
            value = &EG(uninitialized_zval);
43621
0
            goto free_and_exit_assign_obj;
43622
0
          }
43623
0
        }
43624
464
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43625
30
          rebuild_object_properties_internal(zobj);
43626
30
        }
43627
464
        if (EXPECTED(zobj->properties != NULL)) {
43628
446
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43629
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43630
0
              GC_DELREF(zobj->properties);
43631
0
            }
43632
0
            zobj->properties = zend_array_dup(zobj->properties);
43633
0
          }
43634
446
          property_val = zend_hash_find_known_hash(zobj->properties, name);
43635
446
          if (property_val) {
43636
76
            goto fast_assign_obj;
43637
76
          }
43638
446
        }
43639
43640
388
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43641
30
          if (IS_TMP_VAR == IS_CONST) {
43642
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43643
0
              Z_ADDREF_P(value);
43644
0
            }
43645
30
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
43646
0
            if (Z_ISREF_P(value)) {
43647
0
              if (IS_TMP_VAR == IS_VAR) {
43648
0
                zend_reference *ref = Z_REF_P(value);
43649
0
                if (GC_DELREF(ref) == 0) {
43650
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43651
0
                  efree_size(ref, sizeof(zend_reference));
43652
0
                  value = &tmp;
43653
0
                } else {
43654
0
                  value = Z_REFVAL_P(value);
43655
0
                  Z_TRY_ADDREF_P(value);
43656
0
                }
43657
0
              } else {
43658
0
                value = Z_REFVAL_P(value);
43659
0
                Z_TRY_ADDREF_P(value);
43660
0
              }
43661
0
            } else if (IS_TMP_VAR == IS_CV) {
43662
0
              Z_TRY_ADDREF_P(value);
43663
0
            }
43664
0
          }
43665
30
          zend_hash_add_new(zobj->properties, name, value);
43666
30
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43667
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
43668
0
          }
43669
30
          goto exit_assign_obj;
43670
30
        }
43671
388
      } else {
43672
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43673
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43674
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
43675
0
          prop_offset = prop_info->offset;
43676
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43677
0
            prop_info = NULL;
43678
0
          }
43679
0
          goto assign_obj_simple;
43680
0
        }
43681
        /* Fall through to write_property for hooks. */
43682
0
      }
43683
847
    }
43684
756
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43685
756
  } else {
43686
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43687
0
    if (UNEXPECTED(!name)) {
43688
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43689
0
      UNDEF_RESULT();
43690
0
      goto exit_assign_obj;
43691
0
    }
43692
0
  }
43693
43694
756
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
43695
0
    ZVAL_DEREF(value);
43696
0
  }
43697
43698
756
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43699
43700
756
  if (IS_CONST != IS_CONST) {
43701
0
    zend_tmp_string_release(tmp_name);
43702
0
  }
43703
43704
1.10k
free_and_exit_assign_obj:
43705
1.10k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43706
903
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43707
903
  }
43708
1.10k
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43709
1.26k
exit_assign_obj:
43710
1.26k
  if (garbage) {
43711
123
    GC_DTOR_NO_REF(garbage);
43712
123
  }
43713
43714
43715
  /* assign_obj has two opcodes! */
43716
1.26k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
43717
1.26k
}
43718
43719
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43720
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43721
1.13k
{
43722
1.13k
  USE_OPLINE
43723
1.13k
  zval *object, *value, tmp;
43724
1.13k
  zend_object *zobj;
43725
1.13k
  zend_string *name, *tmp_name;
43726
1.13k
  zend_refcounted *garbage = NULL;
43727
43728
1.13k
  SAVE_OPLINE();
43729
1.13k
  object = EX_VAR(opline->op1.var);
43730
1.13k
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43731
43732
1.13k
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43733
90
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43734
65
      object = Z_REFVAL_P(object);
43735
65
      goto assign_object;
43736
65
    }
43737
25
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43738
25
    value = &EG(uninitialized_zval);
43739
25
    goto free_and_exit_assign_obj;
43740
90
  }
43741
43742
1.10k
assign_object:
43743
1.10k
  zobj = Z_OBJ_P(object);
43744
1.10k
  if (IS_CONST == IS_CONST) {
43745
1.10k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43746
522
      void **cache_slot = CACHE_ADDR(opline->extended_value);
43747
522
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43748
522
      zval *property_val;
43749
522
      zend_property_info *prop_info;
43750
43751
522
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43752
30
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43753
43754
30
assign_obj_simple:
43755
30
        property_val = OBJ_PROP(zobj, prop_offset);
43756
30
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
43757
30
          if (prop_info != NULL) {
43758
10
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43759
10
            goto free_and_exit_assign_obj;
43760
20
          } else {
43761
28
fast_assign_obj:
43762
28
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
43763
28
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43764
14
              ZVAL_COPY(EX_VAR(opline->result.var), value);
43765
14
            }
43766
28
            goto exit_assign_obj;
43767
20
          }
43768
30
        }
43769
492
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43770
492
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43771
492
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43772
0
          zobj = zend_lazy_object_init(zobj);
43773
0
          if (!zobj) {
43774
0
            value = &EG(uninitialized_zval);
43775
0
            goto free_and_exit_assign_obj;
43776
0
          }
43777
0
        }
43778
492
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43779
138
          rebuild_object_properties_internal(zobj);
43780
138
        }
43781
492
        if (EXPECTED(zobj->properties != NULL)) {
43782
146
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43783
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43784
0
              GC_DELREF(zobj->properties);
43785
0
            }
43786
0
            zobj->properties = zend_array_dup(zobj->properties);
43787
0
          }
43788
146
          property_val = zend_hash_find_known_hash(zobj->properties, name);
43789
146
          if (property_val) {
43790
8
            goto fast_assign_obj;
43791
8
          }
43792
146
        }
43793
43794
484
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43795
138
          if (IS_VAR == IS_CONST) {
43796
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43797
0
              Z_ADDREF_P(value);
43798
0
            }
43799
138
          } else if (IS_VAR != IS_TMP_VAR) {
43800
138
            if (Z_ISREF_P(value)) {
43801
0
              if (IS_VAR == IS_VAR) {
43802
0
                zend_reference *ref = Z_REF_P(value);
43803
0
                if (GC_DELREF(ref) == 0) {
43804
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43805
0
                  efree_size(ref, sizeof(zend_reference));
43806
0
                  value = &tmp;
43807
0
                } else {
43808
0
                  value = Z_REFVAL_P(value);
43809
0
                  Z_TRY_ADDREF_P(value);
43810
0
                }
43811
0
              } else {
43812
0
                value = Z_REFVAL_P(value);
43813
0
                Z_TRY_ADDREF_P(value);
43814
0
              }
43815
138
            } else if (IS_VAR == IS_CV) {
43816
0
              Z_TRY_ADDREF_P(value);
43817
0
            }
43818
138
          }
43819
138
          zend_hash_add_new(zobj->properties, name, value);
43820
138
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43821
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
43822
0
          }
43823
138
          goto exit_assign_obj;
43824
138
        }
43825
484
      } else {
43826
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43827
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43828
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
43829
0
          prop_offset = prop_info->offset;
43830
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43831
0
            prop_info = NULL;
43832
0
          }
43833
0
          goto assign_obj_simple;
43834
0
        }
43835
        /* Fall through to write_property for hooks. */
43836
0
      }
43837
522
    }
43838
931
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43839
931
  } else {
43840
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43841
0
    if (UNEXPECTED(!name)) {
43842
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43843
0
      UNDEF_RESULT();
43844
0
      goto exit_assign_obj;
43845
0
    }
43846
0
  }
43847
43848
931
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
43849
931
    ZVAL_DEREF(value);
43850
931
  }
43851
43852
931
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43853
43854
931
  if (IS_CONST != IS_CONST) {
43855
0
    zend_tmp_string_release(tmp_name);
43856
0
  }
43857
43858
966
free_and_exit_assign_obj:
43859
966
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43860
439
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43861
439
  }
43862
966
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43863
1.13k
exit_assign_obj:
43864
1.13k
  if (garbage) {
43865
2
    GC_DTOR_NO_REF(garbage);
43866
2
  }
43867
43868
43869
  /* assign_obj has two opcodes! */
43870
1.13k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
43871
1.13k
}
43872
43873
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43874
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43875
4.24k
{
43876
4.24k
  USE_OPLINE
43877
4.24k
  zval *object, *value, tmp;
43878
4.24k
  zend_object *zobj;
43879
4.24k
  zend_string *name, *tmp_name;
43880
4.24k
  zend_refcounted *garbage = NULL;
43881
43882
4.24k
  SAVE_OPLINE();
43883
4.24k
  object = EX_VAR(opline->op1.var);
43884
4.24k
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
43885
43886
4.24k
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43887
110
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43888
42
      object = Z_REFVAL_P(object);
43889
42
      goto assign_object;
43890
42
    }
43891
68
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43892
68
    value = &EG(uninitialized_zval);
43893
68
    goto free_and_exit_assign_obj;
43894
110
  }
43895
43896
4.17k
assign_object:
43897
4.17k
  zobj = Z_OBJ_P(object);
43898
4.17k
  if (IS_CONST == IS_CONST) {
43899
4.17k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43900
3.35k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
43901
3.35k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43902
3.35k
      zval *property_val;
43903
3.35k
      zend_property_info *prop_info;
43904
43905
3.35k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43906
2.40k
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43907
43908
2.40k
assign_obj_simple:
43909
2.40k
        property_val = OBJ_PROP(zobj, prop_offset);
43910
2.40k
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
43911
2.40k
          if (prop_info != NULL) {
43912
5
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43913
5
            goto free_and_exit_assign_obj;
43914
2.39k
          } else {
43915
2.61k
fast_assign_obj:
43916
2.61k
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
43917
2.61k
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43918
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
43919
0
            }
43920
2.61k
            goto exit_assign_obj;
43921
2.39k
          }
43922
2.40k
        }
43923
2.40k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43924
947
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43925
947
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43926
0
          zobj = zend_lazy_object_init(zobj);
43927
0
          if (!zobj) {
43928
0
            value = &EG(uninitialized_zval);
43929
0
            goto free_and_exit_assign_obj;
43930
0
          }
43931
0
        }
43932
947
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43933
824
          rebuild_object_properties_internal(zobj);
43934
824
        }
43935
947
        if (EXPECTED(zobj->properties != NULL)) {
43936
826
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43937
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43938
0
              GC_DELREF(zobj->properties);
43939
0
            }
43940
0
            zobj->properties = zend_array_dup(zobj->properties);
43941
0
          }
43942
826
          property_val = zend_hash_find_known_hash(zobj->properties, name);
43943
826
          if (property_val) {
43944
220
            goto fast_assign_obj;
43945
220
          }
43946
826
        }
43947
43948
727
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43949
606
          if (IS_CV == IS_CONST) {
43950
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43951
0
              Z_ADDREF_P(value);
43952
0
            }
43953
606
          } else if (IS_CV != IS_TMP_VAR) {
43954
606
            if (Z_ISREF_P(value)) {
43955
0
              if (IS_CV == IS_VAR) {
43956
0
                zend_reference *ref = Z_REF_P(value);
43957
0
                if (GC_DELREF(ref) == 0) {
43958
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43959
0
                  efree_size(ref, sizeof(zend_reference));
43960
0
                  value = &tmp;
43961
0
                } else {
43962
0
                  value = Z_REFVAL_P(value);
43963
0
                  Z_TRY_ADDREF_P(value);
43964
0
                }
43965
0
              } else {
43966
0
                value = Z_REFVAL_P(value);
43967
0
                Z_TRY_ADDREF_P(value);
43968
0
              }
43969
606
            } else if (IS_CV == IS_CV) {
43970
606
              Z_TRY_ADDREF_P(value);
43971
606
            }
43972
606
          }
43973
606
          zend_hash_add_new(zobj->properties, name, value);
43974
606
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43975
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
43976
0
          }
43977
606
          goto exit_assign_obj;
43978
606
        }
43979
727
      } else {
43980
5
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43981
5
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43982
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
43983
0
          prop_offset = prop_info->offset;
43984
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43985
0
            prop_info = NULL;
43986
0
          }
43987
0
          goto assign_obj_simple;
43988
0
        }
43989
        /* Fall through to write_property for hooks. */
43990
5
      }
43991
3.35k
    }
43992
947
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43993
947
  } else {
43994
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43995
0
    if (UNEXPECTED(!name)) {
43996
43997
0
      UNDEF_RESULT();
43998
0
      goto exit_assign_obj;
43999
0
    }
44000
0
  }
44001
44002
947
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
44003
947
    ZVAL_DEREF(value);
44004
947
  }
44005
44006
947
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
44007
44008
947
  if (IS_CONST != IS_CONST) {
44009
0
    zend_tmp_string_release(tmp_name);
44010
0
  }
44011
44012
1.02k
free_and_exit_assign_obj:
44013
1.02k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
44014
49
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
44015
49
  }
44016
44017
4.24k
exit_assign_obj:
44018
4.24k
  if (garbage) {
44019
1.16k
    GC_DTOR_NO_REF(garbage);
44020
1.16k
  }
44021
44022
44023
  /* assign_obj has two opcodes! */
44024
4.24k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44025
4.24k
}
44026
44027
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
44028
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44029
1.88k
{
44030
1.88k
  USE_OPLINE
44031
1.88k
  zval *object_ptr, *orig_object_ptr;
44032
1.88k
  zval *value;
44033
1.88k
  zval *variable_ptr;
44034
1.88k
  zval *dim;
44035
1.88k
  zend_refcounted *garbage = NULL;
44036
44037
1.88k
  SAVE_OPLINE();
44038
1.88k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44039
44040
1.88k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44041
1.43k
try_assign_dim_array:
44042
1.43k
    SEPARATE_ARRAY(object_ptr);
44043
1.43k
    if (IS_CONST == IS_UNUSED) {
44044
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
44045
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44046
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
44047
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44048
0
          GC_ADDREF(ht);
44049
0
        }
44050
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44051
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44052
0
          zend_array_destroy(ht);
44053
0
          goto assign_dim_error;
44054
0
        }
44055
0
      }
44056
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
44057
0
        ZVAL_DEREF(value);
44058
0
      }
44059
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44060
0
      if (UNEXPECTED(value == NULL)) {
44061
0
        zend_cannot_add_element();
44062
0
        goto assign_dim_error;
44063
0
      } else if (IS_CONST == IS_CV) {
44064
0
        if (Z_REFCOUNTED_P(value)) {
44065
0
          Z_ADDREF_P(value);
44066
0
        }
44067
0
      } else if (IS_CONST == IS_VAR) {
44068
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
44069
0
        if (Z_ISREF_P(free_op_data)) {
44070
0
          if (Z_REFCOUNTED_P(value)) {
44071
0
            Z_ADDREF_P(value);
44072
0
          }
44073
0
          zval_ptr_dtor_nogc(free_op_data);
44074
0
        }
44075
0
      } else if (IS_CONST == IS_CONST) {
44076
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44077
0
          Z_ADDREF_P(value);
44078
0
        }
44079
0
      }
44080
1.43k
    } else {
44081
1.43k
      dim = RT_CONSTANT(opline, opline->op2);
44082
1.43k
      if (IS_CONST == IS_CONST) {
44083
1.43k
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44084
1.43k
      } else {
44085
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44086
0
      }
44087
1.43k
      if (UNEXPECTED(variable_ptr == NULL)) {
44088
24
        goto assign_dim_error;
44089
24
      }
44090
1.41k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
44091
1.41k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44092
1.41k
    }
44093
1.41k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44094
187
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44095
187
    }
44096
1.41k
    if (garbage) {
44097
25
      GC_DTOR_NO_REF(garbage);
44098
25
    }
44099
1.41k
  } else {
44100
1.25k
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
44101
416
      object_ptr = Z_REFVAL_P(object_ptr);
44102
416
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44103
397
        goto try_assign_dim_array;
44104
397
      }
44105
416
    }
44106
860
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44107
184
      zend_object *obj = Z_OBJ_P(object_ptr);
44108
44109
184
      GC_ADDREF(obj);
44110
184
      dim = RT_CONSTANT(opline, opline->op2);
44111
184
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44112
0
        dim = ZVAL_UNDEFINED_OP2();
44113
184
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44114
64
        dim++;
44115
64
      }
44116
44117
184
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
44118
184
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44119
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44120
184
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
44121
0
        ZVAL_DEREF(value);
44122
0
      }
44123
44124
184
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44125
44126
184
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44127
0
        zend_objects_store_del(obj);
44128
0
      }
44129
676
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44130
252
      if (IS_CONST == IS_UNUSED) {
44131
0
        zend_use_new_element_for_string();
44132
44133
0
        UNDEF_RESULT();
44134
252
      } else {
44135
252
        dim = RT_CONSTANT(opline, opline->op2);
44136
252
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
44137
252
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44138
44139
252
      }
44140
424
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44141
409
      if (Z_ISREF_P(orig_object_ptr)
44142
409
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44143
409
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44144
0
        dim = RT_CONSTANT(opline, opline->op2);
44145
44146
0
        UNDEF_RESULT();
44147
409
      } else {
44148
409
        HashTable *ht = zend_new_array(8);
44149
409
        uint8_t old_type = Z_TYPE_P(object_ptr);
44150
44151
409
        ZVAL_ARR(object_ptr, ht);
44152
409
        if (UNEXPECTED(old_type == IS_FALSE)) {
44153
19
          GC_ADDREF(ht);
44154
19
          zend_false_to_array_deprecated();
44155
19
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44156
0
            zend_array_destroy(ht);
44157
0
            goto assign_dim_error;
44158
0
          }
44159
19
        }
44160
409
        goto try_assign_dim_array;
44161
409
      }
44162
409
    } else {
44163
15
      zend_use_scalar_as_array();
44164
15
      dim = RT_CONSTANT(opline, opline->op2);
44165
39
assign_dim_error:
44166
44167
39
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44168
18
        ZVAL_NULL(EX_VAR(opline->result.var));
44169
18
      }
44170
39
    }
44171
860
  }
44172
1.88k
  if (IS_CONST != IS_UNUSED) {
44173
44174
1.88k
  }
44175
44176
  /* assign_dim has two opcodes! */
44177
1.88k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44178
1.88k
}
44179
44180
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44181
330
{
44182
330
  USE_OPLINE
44183
330
  zval *object_ptr, *orig_object_ptr;
44184
330
  zval *value;
44185
330
  zval *variable_ptr;
44186
330
  zval *dim;
44187
330
  zend_refcounted *garbage = NULL;
44188
44189
330
  SAVE_OPLINE();
44190
330
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44191
44192
330
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44193
235
try_assign_dim_array:
44194
235
    SEPARATE_ARRAY(object_ptr);
44195
235
    if (IS_CONST == IS_UNUSED) {
44196
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44197
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44198
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
44199
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44200
0
          GC_ADDREF(ht);
44201
0
        }
44202
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44203
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44204
0
          zend_array_destroy(ht);
44205
0
          goto assign_dim_error;
44206
0
        }
44207
0
      }
44208
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
44209
0
        ZVAL_DEREF(value);
44210
0
      }
44211
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44212
0
      if (UNEXPECTED(value == NULL)) {
44213
0
        zend_cannot_add_element();
44214
0
        goto assign_dim_error;
44215
0
      } else if (IS_TMP_VAR == IS_CV) {
44216
0
        if (Z_REFCOUNTED_P(value)) {
44217
0
          Z_ADDREF_P(value);
44218
0
        }
44219
0
      } else if (IS_TMP_VAR == IS_VAR) {
44220
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
44221
0
        if (Z_ISREF_P(free_op_data)) {
44222
0
          if (Z_REFCOUNTED_P(value)) {
44223
0
            Z_ADDREF_P(value);
44224
0
          }
44225
0
          zval_ptr_dtor_nogc(free_op_data);
44226
0
        }
44227
0
      } else if (IS_TMP_VAR == IS_CONST) {
44228
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44229
0
          Z_ADDREF_P(value);
44230
0
        }
44231
0
      }
44232
235
    } else {
44233
235
      dim = RT_CONSTANT(opline, opline->op2);
44234
235
      if (IS_CONST == IS_CONST) {
44235
235
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44236
235
      } else {
44237
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44238
0
      }
44239
235
      if (UNEXPECTED(variable_ptr == NULL)) {
44240
0
        goto assign_dim_error;
44241
0
      }
44242
235
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44243
235
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
44244
235
    }
44245
235
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44246
48
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44247
48
    }
44248
235
    if (garbage) {
44249
0
      GC_DTOR_NO_REF(garbage);
44250
0
    }
44251
244
  } else {
44252
244
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
44253
91
      object_ptr = Z_REFVAL_P(object_ptr);
44254
91
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44255
80
        goto try_assign_dim_array;
44256
80
      }
44257
91
    }
44258
164
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44259
59
      zend_object *obj = Z_OBJ_P(object_ptr);
44260
44261
59
      GC_ADDREF(obj);
44262
59
      dim = RT_CONSTANT(opline, opline->op2);
44263
59
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44264
0
        dim = ZVAL_UNDEFINED_OP2();
44265
59
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44266
0
        dim++;
44267
0
      }
44268
44269
59
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44270
59
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44271
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44272
59
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
44273
0
        ZVAL_DEREF(value);
44274
0
      }
44275
44276
59
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44277
44278
59
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44279
59
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44280
0
        zend_objects_store_del(obj);
44281
0
      }
44282
105
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44283
36
      if (IS_CONST == IS_UNUSED) {
44284
0
        zend_use_new_element_for_string();
44285
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44286
0
        UNDEF_RESULT();
44287
36
      } else {
44288
36
        dim = RT_CONSTANT(opline, opline->op2);
44289
36
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44290
36
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44291
36
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44292
36
      }
44293
69
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44294
69
      if (Z_ISREF_P(orig_object_ptr)
44295
69
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44296
69
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44297
0
        dim = RT_CONSTANT(opline, opline->op2);
44298
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44299
0
        UNDEF_RESULT();
44300
69
      } else {
44301
69
        HashTable *ht = zend_new_array(8);
44302
69
        uint8_t old_type = Z_TYPE_P(object_ptr);
44303
44304
69
        ZVAL_ARR(object_ptr, ht);
44305
69
        if (UNEXPECTED(old_type == IS_FALSE)) {
44306
0
          GC_ADDREF(ht);
44307
0
          zend_false_to_array_deprecated();
44308
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44309
0
            zend_array_destroy(ht);
44310
0
            goto assign_dim_error;
44311
0
          }
44312
0
        }
44313
69
        goto try_assign_dim_array;
44314
69
      }
44315
69
    } else {
44316
0
      zend_use_scalar_as_array();
44317
0
      dim = RT_CONSTANT(opline, opline->op2);
44318
0
assign_dim_error:
44319
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44320
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44321
0
        ZVAL_NULL(EX_VAR(opline->result.var));
44322
0
      }
44323
0
    }
44324
164
  }
44325
330
  if (IS_CONST != IS_UNUSED) {
44326
44327
330
  }
44328
44329
  /* assign_dim has two opcodes! */
44330
330
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44331
330
}
44332
44333
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44334
437
{
44335
437
  USE_OPLINE
44336
437
  zval *object_ptr, *orig_object_ptr;
44337
437
  zval *value;
44338
437
  zval *variable_ptr;
44339
437
  zval *dim;
44340
437
  zend_refcounted *garbage = NULL;
44341
44342
437
  SAVE_OPLINE();
44343
437
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44344
44345
437
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44346
424
try_assign_dim_array:
44347
424
    SEPARATE_ARRAY(object_ptr);
44348
424
    if (IS_CONST == IS_UNUSED) {
44349
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44350
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44351
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
44352
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44353
0
          GC_ADDREF(ht);
44354
0
        }
44355
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44356
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44357
0
          zend_array_destroy(ht);
44358
0
          goto assign_dim_error;
44359
0
        }
44360
0
      }
44361
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
44362
0
        ZVAL_DEREF(value);
44363
0
      }
44364
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44365
0
      if (UNEXPECTED(value == NULL)) {
44366
0
        zend_cannot_add_element();
44367
0
        goto assign_dim_error;
44368
0
      } else if (IS_VAR == IS_CV) {
44369
0
        if (Z_REFCOUNTED_P(value)) {
44370
0
          Z_ADDREF_P(value);
44371
0
        }
44372
0
      } else if (IS_VAR == IS_VAR) {
44373
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
44374
0
        if (Z_ISREF_P(free_op_data)) {
44375
0
          if (Z_REFCOUNTED_P(value)) {
44376
0
            Z_ADDREF_P(value);
44377
0
          }
44378
0
          zval_ptr_dtor_nogc(free_op_data);
44379
0
        }
44380
0
      } else if (IS_VAR == IS_CONST) {
44381
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44382
0
          Z_ADDREF_P(value);
44383
0
        }
44384
0
      }
44385
424
    } else {
44386
424
      dim = RT_CONSTANT(opline, opline->op2);
44387
424
      if (IS_CONST == IS_CONST) {
44388
424
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44389
424
      } else {
44390
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44391
0
      }
44392
424
      if (UNEXPECTED(variable_ptr == NULL)) {
44393
0
        goto assign_dim_error;
44394
0
      }
44395
424
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44396
424
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
44397
424
    }
44398
424
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44399
10
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44400
10
    }
44401
424
    if (garbage) {
44402
243
      GC_DTOR_NO_REF(garbage);
44403
243
    }
44404
424
  } else {
44405
120
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
44406
0
      object_ptr = Z_REFVAL_P(object_ptr);
44407
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44408
0
        goto try_assign_dim_array;
44409
0
      }
44410
0
    }
44411
120
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44412
13
      zend_object *obj = Z_OBJ_P(object_ptr);
44413
44414
13
      GC_ADDREF(obj);
44415
13
      dim = RT_CONSTANT(opline, opline->op2);
44416
13
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44417
0
        dim = ZVAL_UNDEFINED_OP2();
44418
13
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44419
0
        dim++;
44420
0
      }
44421
44422
13
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44423
13
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44424
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44425
13
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
44426
13
        ZVAL_DEREF(value);
44427
13
      }
44428
44429
13
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44430
44431
13
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44432
13
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44433
0
        zend_objects_store_del(obj);
44434
0
      }
44435
107
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44436
0
      if (IS_CONST == IS_UNUSED) {
44437
0
        zend_use_new_element_for_string();
44438
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44439
0
        UNDEF_RESULT();
44440
0
      } else {
44441
0
        dim = RT_CONSTANT(opline, opline->op2);
44442
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44443
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44444
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44445
0
      }
44446
107
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44447
107
      if (Z_ISREF_P(orig_object_ptr)
44448
107
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44449
107
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44450
0
        dim = RT_CONSTANT(opline, opline->op2);
44451
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44452
0
        UNDEF_RESULT();
44453
107
      } else {
44454
107
        HashTable *ht = zend_new_array(8);
44455
107
        uint8_t old_type = Z_TYPE_P(object_ptr);
44456
44457
107
        ZVAL_ARR(object_ptr, ht);
44458
107
        if (UNEXPECTED(old_type == IS_FALSE)) {
44459
0
          GC_ADDREF(ht);
44460
0
          zend_false_to_array_deprecated();
44461
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44462
0
            zend_array_destroy(ht);
44463
0
            goto assign_dim_error;
44464
0
          }
44465
0
        }
44466
107
        goto try_assign_dim_array;
44467
107
      }
44468
107
    } else {
44469
0
      zend_use_scalar_as_array();
44470
0
      dim = RT_CONSTANT(opline, opline->op2);
44471
0
assign_dim_error:
44472
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44473
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44474
0
        ZVAL_NULL(EX_VAR(opline->result.var));
44475
0
      }
44476
0
    }
44477
120
  }
44478
437
  if (IS_CONST != IS_UNUSED) {
44479
44480
437
  }
44481
44482
  /* assign_dim has two opcodes! */
44483
437
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44484
437
}
44485
44486
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44487
935
{
44488
935
  USE_OPLINE
44489
935
  zval *object_ptr, *orig_object_ptr;
44490
935
  zval *value;
44491
935
  zval *variable_ptr;
44492
935
  zval *dim;
44493
935
  zend_refcounted *garbage = NULL;
44494
44495
935
  SAVE_OPLINE();
44496
935
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44497
44498
935
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44499
655
try_assign_dim_array:
44500
655
    SEPARATE_ARRAY(object_ptr);
44501
655
    if (IS_CONST == IS_UNUSED) {
44502
0
      value = EX_VAR((opline+1)->op1.var);
44503
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44504
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
44505
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44506
0
          GC_ADDREF(ht);
44507
0
        }
44508
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44509
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44510
0
          zend_array_destroy(ht);
44511
0
          goto assign_dim_error;
44512
0
        }
44513
0
      }
44514
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
44515
0
        ZVAL_DEREF(value);
44516
0
      }
44517
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44518
0
      if (UNEXPECTED(value == NULL)) {
44519
0
        zend_cannot_add_element();
44520
0
        goto assign_dim_error;
44521
0
      } else if (IS_CV == IS_CV) {
44522
0
        if (Z_REFCOUNTED_P(value)) {
44523
0
          Z_ADDREF_P(value);
44524
0
        }
44525
0
      } else if (IS_CV == IS_VAR) {
44526
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
44527
0
        if (Z_ISREF_P(free_op_data)) {
44528
0
          if (Z_REFCOUNTED_P(value)) {
44529
0
            Z_ADDREF_P(value);
44530
0
          }
44531
0
          zval_ptr_dtor_nogc(free_op_data);
44532
0
        }
44533
0
      } else if (IS_CV == IS_CONST) {
44534
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44535
0
          Z_ADDREF_P(value);
44536
0
        }
44537
0
      }
44538
655
    } else {
44539
655
      dim = RT_CONSTANT(opline, opline->op2);
44540
655
      if (IS_CONST == IS_CONST) {
44541
655
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44542
655
      } else {
44543
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44544
0
      }
44545
655
      if (UNEXPECTED(variable_ptr == NULL)) {
44546
0
        goto assign_dim_error;
44547
0
      }
44548
655
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
44549
655
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
44550
655
    }
44551
655
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44552
489
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44553
489
    }
44554
655
    if (garbage) {
44555
199
      GC_DTOR_NO_REF(garbage);
44556
199
    }
44557
655
  } else {
44558
436
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
44559
0
      object_ptr = Z_REFVAL_P(object_ptr);
44560
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44561
0
        goto try_assign_dim_array;
44562
0
      }
44563
0
    }
44564
436
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44565
158
      zend_object *obj = Z_OBJ_P(object_ptr);
44566
44567
158
      GC_ADDREF(obj);
44568
158
      dim = RT_CONSTANT(opline, opline->op2);
44569
158
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44570
0
        dim = ZVAL_UNDEFINED_OP2();
44571
158
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44572
0
        dim++;
44573
0
      }
44574
44575
158
      value = EX_VAR((opline+1)->op1.var);
44576
158
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44577
25
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44578
133
      } else if (IS_CV & (IS_CV|IS_VAR)) {
44579
133
        ZVAL_DEREF(value);
44580
133
      }
44581
44582
158
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44583
44584
158
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44585
0
        zend_objects_store_del(obj);
44586
0
      }
44587
278
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44588
70
      if (IS_CONST == IS_UNUSED) {
44589
0
        zend_use_new_element_for_string();
44590
44591
0
        UNDEF_RESULT();
44592
70
      } else {
44593
70
        dim = RT_CONSTANT(opline, opline->op2);
44594
70
        value = EX_VAR((opline+1)->op1.var);
44595
70
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44596
44597
70
      }
44598
208
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44599
156
      if (Z_ISREF_P(orig_object_ptr)
44600
156
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44601
156
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44602
0
        dim = RT_CONSTANT(opline, opline->op2);
44603
44604
0
        UNDEF_RESULT();
44605
156
      } else {
44606
156
        HashTable *ht = zend_new_array(8);
44607
156
        uint8_t old_type = Z_TYPE_P(object_ptr);
44608
44609
156
        ZVAL_ARR(object_ptr, ht);
44610
156
        if (UNEXPECTED(old_type == IS_FALSE)) {
44611
13
          GC_ADDREF(ht);
44612
13
          zend_false_to_array_deprecated();
44613
13
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44614
0
            zend_array_destroy(ht);
44615
0
            goto assign_dim_error;
44616
0
          }
44617
13
        }
44618
156
        goto try_assign_dim_array;
44619
156
      }
44620
156
    } else {
44621
52
      zend_use_scalar_as_array();
44622
52
      dim = RT_CONSTANT(opline, opline->op2);
44623
52
assign_dim_error:
44624
44625
52
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44626
0
        ZVAL_NULL(EX_VAR(opline->result.var));
44627
0
      }
44628
52
    }
44629
436
  }
44630
935
  if (IS_CONST != IS_UNUSED) {
44631
44632
935
  }
44633
44634
  /* assign_dim has two opcodes! */
44635
935
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44636
935
}
44637
44638
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44639
590k
{
44640
590k
  USE_OPLINE
44641
590k
  zval *value;
44642
590k
  zval *variable_ptr;
44643
44644
590k
  SAVE_OPLINE();
44645
590k
  value = RT_CONSTANT(opline, opline->op2);
44646
590k
  variable_ptr = EX_VAR(opline->op1.var);
44647
44648
590k
  if (0 || UNEXPECTED(0)) {
44649
0
    zend_refcounted *garbage = NULL;
44650
44651
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44652
0
    if (UNEXPECTED(0)) {
44653
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44654
0
    }
44655
0
    if (garbage) {
44656
0
      GC_DTOR_NO_REF(garbage);
44657
0
    }
44658
590k
  } else {
44659
590k
    value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
44660
590k
  }
44661
44662
  /* zend_assign_to_variable() always takes care of op2, never free it! */
44663
44664
590k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44665
590k
}
44666
44667
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44668
635k
{
44669
635k
  USE_OPLINE
44670
635k
  zval *value;
44671
635k
  zval *variable_ptr;
44672
44673
635k
  SAVE_OPLINE();
44674
635k
  value = RT_CONSTANT(opline, opline->op2);
44675
635k
  variable_ptr = EX_VAR(opline->op1.var);
44676
44677
635k
  if (0 || UNEXPECTED(1)) {
44678
635k
    zend_refcounted *garbage = NULL;
44679
44680
635k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44681
635k
    if (UNEXPECTED(1)) {
44682
635k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44683
635k
    }
44684
635k
    if (garbage) {
44685
15.7k
      GC_DTOR_NO_REF(garbage);
44686
15.7k
    }
44687
635k
  } else {
44688
0
    value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
44689
0
  }
44690
44691
  /* zend_assign_to_variable() always takes care of op2, never free it! */
44692
44693
635k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44694
635k
}
44695
44696
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44697
95
{
44698
95
  USE_OPLINE
44699
95
  zval *property, *container, *value_ptr;
44700
44701
95
  SAVE_OPLINE();
44702
44703
95
  container = EX_VAR(opline->op1.var);
44704
95
  property = RT_CONSTANT(opline, opline->op2);
44705
44706
95
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44707
44708
95
  if (1) {
44709
95
    if (IS_CV == IS_UNUSED) {
44710
0
      if (IS_CONST == IS_CONST) {
44711
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44712
0
      } else {
44713
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44714
0
      }
44715
95
    } else {
44716
95
      if (IS_CONST == IS_CONST) {
44717
95
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44718
95
      } else {
44719
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44720
0
      }
44721
95
    }
44722
95
  } else {
44723
0
    zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44724
0
  }
44725
44726
44727
95
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44728
95
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44729
95
}
44730
44731
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
44732
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44733
265
{
44734
265
  USE_OPLINE
44735
265
  zval *property, *container, *value_ptr;
44736
44737
265
  SAVE_OPLINE();
44738
44739
265
  container = EX_VAR(opline->op1.var);
44740
265
  property = RT_CONSTANT(opline, opline->op2);
44741
44742
265
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
44743
44744
265
  if (1) {
44745
265
    if (IS_CV == IS_UNUSED) {
44746
0
      if (IS_CONST == IS_CONST) {
44747
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44748
0
      } else {
44749
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44750
0
      }
44751
265
    } else {
44752
265
      if (IS_CONST == IS_CONST) {
44753
265
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44754
265
      } else {
44755
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44756
0
      }
44757
265
    }
44758
265
  } else {
44759
0
    zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44760
0
  }
44761
44762
44763
44764
265
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44765
265
}
44766
44767
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
44768
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44769
100k
{
44770
100k
  USE_OPLINE
44771
100k
  zval *op1, *op2;
44772
100k
  zend_string *op1_str, *op2_str, *str;
44773
44774
44775
100k
  op1 = EX_VAR(opline->op1.var);
44776
100k
  op2 = RT_CONSTANT(opline, opline->op2);
44777
100k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
44778
100k
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
44779
1.89k
    zend_string *op1_str = Z_STR_P(op1);
44780
1.89k
    zend_string *op2_str = Z_STR_P(op2);
44781
1.89k
    zend_string *str;
44782
1.89k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
44783
44784
1.89k
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44785
79
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
44786
79
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
44787
79
      } else {
44788
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44789
0
      }
44790
79
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44791
0
        zend_string_release_ex(op1_str, 0);
44792
0
      }
44793
1.81k
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44794
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
44795
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
44796
0
      } else {
44797
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44798
0
      }
44799
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44800
0
        zend_string_release_ex(op2_str, 0);
44801
0
      }
44802
1.81k
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
44803
1.81k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
44804
0
      size_t len = ZSTR_LEN(op1_str);
44805
44806
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
44807
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44808
0
      GC_ADD_FLAGS(str, flags);
44809
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44810
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44811
0
        zend_string_release_ex(op2_str, 0);
44812
0
      }
44813
1.81k
    } else {
44814
1.81k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44815
1.81k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44816
1.81k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44817
1.81k
      GC_ADD_FLAGS(str, flags);
44818
1.81k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44819
1.81k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44820
0
        zend_string_release_ex(op1_str, 0);
44821
0
      }
44822
1.81k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44823
0
        zend_string_release_ex(op2_str, 0);
44824
0
      }
44825
1.81k
    }
44826
1.89k
    ZEND_VM_NEXT_OPCODE();
44827
1.89k
  }
44828
44829
100k
  SAVE_OPLINE();
44830
98.1k
  if (IS_CV == IS_CONST) {
44831
0
    op1_str = Z_STR_P(op1);
44832
98.1k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44833
0
    op1_str = zend_string_copy(Z_STR_P(op1));
44834
98.1k
  } else {
44835
98.1k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44836
93.1k
      ZVAL_UNDEFINED_OP1();
44837
93.1k
    }
44838
98.1k
    op1_str = zval_get_string_func(op1);
44839
98.1k
  }
44840
98.1k
  if (IS_CONST == IS_CONST) {
44841
98.1k
    op2_str = Z_STR_P(op2);
44842
98.1k
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44843
0
    op2_str = zend_string_copy(Z_STR_P(op2));
44844
0
  } else {
44845
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
44846
0
      ZVAL_UNDEFINED_OP2();
44847
0
    }
44848
0
    op2_str = zval_get_string_func(op2);
44849
0
  }
44850
98.1k
  do {
44851
98.1k
    if (IS_CV != IS_CONST) {
44852
98.1k
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44853
93.3k
        if (IS_CONST == IS_CONST) {
44854
93.3k
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
44855
0
            GC_ADDREF(op2_str);
44856
0
          }
44857
93.3k
        }
44858
93.3k
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44859
93.3k
        zend_string_release_ex(op1_str, 0);
44860
93.3k
        break;
44861
93.3k
      }
44862
98.1k
    }
44863
4.76k
    if (IS_CONST != IS_CONST) {
44864
0
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44865
0
        if (IS_CV == IS_CONST) {
44866
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
44867
0
            GC_ADDREF(op1_str);
44868
0
          }
44869
0
        }
44870
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44871
0
        zend_string_release_ex(op2_str, 0);
44872
0
        break;
44873
0
      }
44874
0
    }
44875
4.76k
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44876
4.76k
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44877
4.76k
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44878
44879
4.76k
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
44880
4.76k
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44881
4.76k
    if (IS_CV != IS_CONST) {
44882
4.76k
      zend_string_release_ex(op1_str, 0);
44883
4.76k
    }
44884
4.76k
    if (IS_CONST != IS_CONST) {
44885
0
      zend_string_release_ex(op2_str, 0);
44886
0
    }
44887
4.76k
  } while (0);
44888
44889
44890
98.1k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44891
98.1k
}
44892
44893
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44894
113k
{
44895
113k
  USE_OPLINE
44896
113k
  zval *function_name;
44897
113k
  zval *object;
44898
113k
  zend_function *fbc;
44899
113k
  zend_class_entry *called_scope;
44900
113k
  zend_object *obj;
44901
113k
  zend_execute_data *call;
44902
113k
  uint32_t call_info;
44903
44904
113k
  SAVE_OPLINE();
44905
44906
113k
  object = EX_VAR(opline->op1.var);
44907
44908
113k
  if (IS_CONST != IS_CONST) {
44909
0
    function_name = RT_CONSTANT(opline, opline->op2);
44910
0
  }
44911
44912
113k
  if (IS_CONST != IS_CONST &&
44913
113k
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
44914
0
    do {
44915
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
44916
0
        function_name = Z_REFVAL_P(function_name);
44917
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
44918
0
          break;
44919
0
        }
44920
0
      } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
44921
0
        ZVAL_UNDEFINED_OP2();
44922
0
        if (UNEXPECTED(EG(exception) != NULL)) {
44923
44924
0
          HANDLE_EXCEPTION();
44925
0
        }
44926
0
      }
44927
0
      zend_throw_error(NULL, "Method name must be a string");
44928
44929
44930
0
      HANDLE_EXCEPTION();
44931
0
    } while (0);
44932
0
  }
44933
44934
113k
  if (IS_CV == IS_UNUSED) {
44935
0
    obj = Z_OBJ_P(object);
44936
113k
  } else {
44937
113k
    do {
44938
113k
      if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
44939
112k
        obj = Z_OBJ_P(object);
44940
112k
      } else {
44941
774
        if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
44942
230
          zend_reference *ref = Z_REF_P(object);
44943
44944
230
          object = &ref->val;
44945
230
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
44946
223
            obj = Z_OBJ_P(object);
44947
223
            if (IS_CV & IS_VAR) {
44948
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
44949
0
                efree_size(ref, sizeof(zend_reference));
44950
0
              } else {
44951
0
                Z_ADDREF_P(object);
44952
0
              }
44953
0
            }
44954
223
            break;
44955
223
          }
44956
230
        }
44957
551
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
44958
382
          object = ZVAL_UNDEFINED_OP1();
44959
382
          if (UNEXPECTED(EG(exception) != NULL)) {
44960
17
            if (IS_CONST != IS_CONST) {
44961
44962
0
            }
44963
17
            HANDLE_EXCEPTION();
44964
17
          }
44965
382
        }
44966
534
        if (IS_CONST == IS_CONST) {
44967
534
          function_name = RT_CONSTANT(opline, opline->op2);
44968
534
        }
44969
534
        zend_invalid_method_call(object, function_name);
44970
44971
44972
534
        HANDLE_EXCEPTION();
44973
534
      }
44974
113k
    } while (0);
44975
113k
  }
44976
44977
113k
  called_scope = obj->ce;
44978
44979
113k
  if (IS_CONST == IS_CONST &&
44980
113k
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
44981
9.98k
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
44982
103k
  } else {
44983
103k
    zend_object *orig_obj = obj;
44984
44985
103k
    if (IS_CONST == IS_CONST) {
44986
103k
      function_name = RT_CONSTANT(opline, opline->op2);
44987
103k
    }
44988
44989
    /* First, locate the function. */
44990
103k
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
44991
103k
    if (UNEXPECTED(fbc == NULL)) {
44992
265
      if (EXPECTED(!EG(exception))) {
44993
240
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
44994
240
      }
44995
44996
265
      if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
44997
0
        zend_objects_store_del(orig_obj);
44998
0
      }
44999
265
      HANDLE_EXCEPTION();
45000
265
    }
45001
102k
    if (IS_CONST == IS_CONST &&
45002
102k
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
45003
102k
        EXPECTED(obj == orig_obj)) {
45004
102k
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
45005
102k
    }
45006
102k
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
45007
0
      GC_ADDREF(obj); /* For $this pointer */
45008
0
      if (GC_DELREF(orig_obj) == 0) {
45009
0
        zend_objects_store_del(orig_obj);
45010
0
      }
45011
0
    }
45012
102k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
45013
3.52k
      init_func_run_time_cache(&fbc->op_array);
45014
3.52k
    }
45015
102k
  }
45016
45017
112k
  if (IS_CONST != IS_CONST) {
45018
45019
0
  }
45020
45021
112k
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
45022
112k
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
45023
20
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
45024
0
      zend_objects_store_del(obj);
45025
0
      if (UNEXPECTED(EG(exception))) {
45026
0
        HANDLE_EXCEPTION();
45027
0
      }
45028
0
    }
45029
    /* call static method */
45030
20
    obj = (zend_object*)called_scope;
45031
20
    call_info = ZEND_CALL_NESTED_FUNCTION;
45032
112k
  } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
45033
112k
    if (IS_CV == IS_CV) {
45034
112k
      GC_ADDREF(obj); /* For $this pointer */
45035
112k
    }
45036
    /* CV may be changed indirectly (e.g. when it's a reference) */
45037
112k
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
45038
112k
  }
45039
45040
112k
  call = zend_vm_stack_push_call_frame(call_info,
45041
112k
    fbc, opline->extended_value, obj);
45042
112k
  call->prev_execute_data = EX(call);
45043
112k
  EX(call) = call;
45044
45045
112k
  ZEND_VM_NEXT_OPCODE();
45046
112k
}
45047
45048
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45049
186
{
45050
186
  USE_OPLINE
45051
186
  zval *varptr, *arg;
45052
45053
186
  if (IS_CONST == IS_CONST) {
45054
186
    SAVE_OPLINE();
45055
186
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45056
186
    uint32_t arg_num;
45057
186
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45058
186
    if (UNEXPECTED(!arg)) {
45059
45060
2
      HANDLE_EXCEPTION();
45061
2
    }
45062
186
  } else {
45063
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45064
0
  }
45065
45066
184
  varptr = EX_VAR(opline->op1.var);
45067
184
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
45068
13
    SAVE_OPLINE();
45069
13
    ZVAL_UNDEFINED_OP1();
45070
13
    ZVAL_NULL(arg);
45071
13
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45072
13
  }
45073
45074
171
  if (IS_CV == IS_CV) {
45075
171
    ZVAL_COPY_DEREF(arg, varptr);
45076
171
  } else /* if (IS_CV == IS_VAR) */ {
45077
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
45078
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
45079
45080
0
      varptr = Z_REFVAL_P(varptr);
45081
0
      ZVAL_COPY_VALUE(arg, varptr);
45082
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45083
0
        efree_size(ref, sizeof(zend_reference));
45084
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
45085
0
        Z_ADDREF_P(arg);
45086
0
      }
45087
0
    } else {
45088
0
      ZVAL_COPY_VALUE(arg, varptr);
45089
0
    }
45090
0
  }
45091
45092
171
  ZEND_VM_NEXT_OPCODE();
45093
171
}
45094
45095
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45096
87
{
45097
87
  USE_OPLINE
45098
87
  zval *varptr, *arg;
45099
45100
87
  SAVE_OPLINE();
45101
87
  if (IS_CONST == IS_CONST) {
45102
87
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45103
87
    uint32_t arg_num;
45104
87
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45105
87
    if (UNEXPECTED(!arg)) {
45106
45107
0
      HANDLE_EXCEPTION();
45108
0
    }
45109
87
  } else {
45110
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45111
0
  }
45112
45113
87
  varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45114
87
  if (Z_ISREF_P(varptr)) {
45115
82
    Z_ADDREF_P(varptr);
45116
82
  } else {
45117
5
    ZVAL_MAKE_REF_EX(varptr, 2);
45118
5
  }
45119
87
  ZVAL_REF(arg, Z_REF_P(varptr));
45120
45121
87
  ZEND_VM_NEXT_OPCODE();
45122
87
}
45123
45124
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45125
354
{
45126
354
  USE_OPLINE
45127
354
  zval *varptr, *arg;
45128
354
  uint32_t arg_num;
45129
45130
354
  if (IS_CONST == IS_CONST) {
45131
354
    SAVE_OPLINE();
45132
354
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45133
354
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45134
354
    if (UNEXPECTED(!arg)) {
45135
45136
6
      HANDLE_EXCEPTION();
45137
6
    }
45138
354
  } else {
45139
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45140
0
    arg_num = opline->op2.num;
45141
0
  }
45142
45143
348
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
45144
308
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
45145
64
      goto send_var_by_ref;
45146
64
    }
45147
308
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
45148
84
send_var_by_ref:
45149
84
    varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45150
84
    if (Z_ISREF_P(varptr)) {
45151
12
      Z_ADDREF_P(varptr);
45152
72
    } else {
45153
72
      ZVAL_MAKE_REF_EX(varptr, 2);
45154
72
    }
45155
84
    ZVAL_REF(arg, Z_REF_P(varptr));
45156
45157
84
    ZEND_VM_NEXT_OPCODE();
45158
84
  }
45159
45160
264
  varptr = EX_VAR(opline->op1.var);
45161
264
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
45162
9
    SAVE_OPLINE();
45163
9
    ZVAL_UNDEFINED_OP1();
45164
9
    ZVAL_NULL(arg);
45165
9
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45166
9
  }
45167
45168
255
  if (IS_CV == IS_CV) {
45169
255
    ZVAL_COPY_DEREF(arg, varptr);
45170
255
  } else /* if (IS_CV == IS_VAR) */ {
45171
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
45172
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
45173
45174
0
      varptr = Z_REFVAL_P(varptr);
45175
0
      ZVAL_COPY_VALUE(arg, varptr);
45176
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45177
0
        efree_size(ref, sizeof(zend_reference));
45178
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
45179
0
        Z_ADDREF_P(arg);
45180
0
      }
45181
0
    } else {
45182
0
      ZVAL_COPY_VALUE(arg, varptr);
45183
0
    }
45184
0
  }
45185
45186
255
  ZEND_VM_NEXT_OPCODE();
45187
255
}
45188
45189
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45190
226
{
45191
226
  USE_OPLINE
45192
226
  zval *expr_ptr, new_expr;
45193
45194
226
  SAVE_OPLINE();
45195
226
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
45196
226
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
45197
18
    expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45198
18
    if (Z_ISREF_P(expr_ptr)) {
45199
0
      Z_ADDREF_P(expr_ptr);
45200
18
    } else {
45201
18
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
45202
18
    }
45203
45204
208
  } else {
45205
208
    expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45206
208
    if (IS_CV == IS_TMP_VAR) {
45207
      /* pass */
45208
208
    } else if (IS_CV == IS_CONST) {
45209
0
      Z_TRY_ADDREF_P(expr_ptr);
45210
208
    } else if (IS_CV == IS_CV) {
45211
208
      ZVAL_DEREF(expr_ptr);
45212
208
      Z_TRY_ADDREF_P(expr_ptr);
45213
208
    } else /* if (IS_CV == IS_VAR) */ {
45214
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
45215
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
45216
45217
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
45218
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45219
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
45220
0
          expr_ptr = &new_expr;
45221
0
          efree_size(ref, sizeof(zend_reference));
45222
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
45223
0
          Z_ADDREF_P(expr_ptr);
45224
0
        }
45225
0
      }
45226
0
    }
45227
208
  }
45228
45229
226
  if (IS_CONST != IS_UNUSED) {
45230
226
    zval *offset = RT_CONSTANT(opline, opline->op2);
45231
226
    zend_string *str;
45232
226
    zend_ulong hval;
45233
45234
226
add_again:
45235
226
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45236
216
      str = Z_STR_P(offset);
45237
216
      if (IS_CONST != IS_CONST) {
45238
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
45239
0
          goto num_index;
45240
0
        }
45241
0
      }
45242
216
str_index:
45243
216
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
45244
216
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45245
2
      hval = Z_LVAL_P(offset);
45246
4
num_index:
45247
4
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
45248
8
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
45249
0
      offset = Z_REFVAL_P(offset);
45250
0
      goto add_again;
45251
8
    } else if (Z_TYPE_P(offset) == IS_NULL) {
45252
0
      str = ZSTR_EMPTY_ALLOC();
45253
0
      goto str_index;
45254
8
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
45255
2
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
45256
2
      goto num_index;
45257
6
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
45258
0
      hval = 0;
45259
0
      goto num_index;
45260
6
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
45261
0
      hval = 1;
45262
0
      goto num_index;
45263
6
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
45264
0
      zend_use_resource_as_offset(offset);
45265
0
      hval = Z_RES_HANDLE_P(offset);
45266
0
      goto num_index;
45267
6
    } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
45268
0
      ZVAL_UNDEFINED_OP2();
45269
0
      str = ZSTR_EMPTY_ALLOC();
45270
0
      goto str_index;
45271
6
    } else {
45272
6
      zend_illegal_array_offset_access(offset);
45273
6
      zval_ptr_dtor_nogc(expr_ptr);
45274
6
    }
45275
45276
226
  } else {
45277
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
45278
0
      zend_cannot_add_element();
45279
0
      zval_ptr_dtor_nogc(expr_ptr);
45280
0
    }
45281
0
  }
45282
226
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45283
226
}
45284
45285
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45286
123
{
45287
123
  zval *array;
45288
123
  uint32_t size;
45289
123
  USE_OPLINE
45290
45291
123
  SAVE_OPLINE();
45292
123
  array = EX_VAR(opline->result.var);
45293
123
  if (IS_CV != IS_UNUSED) {
45294
123
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
45295
123
    ZVAL_ARR(array, zend_new_array(size));
45296
    /* Explicitly initialize array as not-packed if flag is set */
45297
123
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
45298
113
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
45299
113
    }
45300
123
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45301
123
  } else {
45302
0
    ZVAL_ARR(array, zend_new_array(0));
45303
0
    ZEND_VM_NEXT_OPCODE();
45304
0
  }
45305
123
}
45306
45307
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45308
1.12k
{
45309
1.12k
  USE_OPLINE
45310
1.12k
  zval *container;
45311
1.12k
  zval *offset;
45312
1.12k
  zend_ulong hval;
45313
1.12k
  zend_string *key;
45314
45315
1.12k
  SAVE_OPLINE();
45316
1.12k
  container = EX_VAR(opline->op1.var);
45317
1.12k
  offset = RT_CONSTANT(opline, opline->op2);
45318
45319
1.12k
  do {
45320
1.12k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45321
404
      HashTable *ht;
45322
45323
591
unset_dim_array:
45324
591
      SEPARATE_ARRAY(container);
45325
591
      ht = Z_ARRVAL_P(container);
45326
591
offset_again:
45327
591
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45328
316
        key = Z_STR_P(offset);
45329
316
        if (IS_CONST != IS_CONST) {
45330
0
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
45331
0
            goto num_index_dim;
45332
0
          }
45333
0
        }
45334
316
str_index_dim:
45335
316
        ZEND_ASSERT(ht != &EG(symbol_table));
45336
316
        zend_hash_del(ht, key);
45337
316
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45338
270
        hval = Z_LVAL_P(offset);
45339
270
num_index_dim:
45340
270
        zend_hash_index_del(ht, hval);
45341
270
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
45342
0
        offset = Z_REFVAL_P(offset);
45343
0
        goto offset_again;
45344
5
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
45345
0
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
45346
0
        goto num_index_dim;
45347
5
      } else if (Z_TYPE_P(offset) == IS_NULL) {
45348
0
        key = ZSTR_EMPTY_ALLOC();
45349
0
        goto str_index_dim;
45350
5
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
45351
0
        hval = 0;
45352
0
        goto num_index_dim;
45353
5
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
45354
0
        hval = 1;
45355
0
        goto num_index_dim;
45356
5
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
45357
0
        zend_use_resource_as_offset(offset);
45358
0
        hval = Z_RES_HANDLE_P(offset);
45359
0
        goto num_index_dim;
45360
5
      } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
45361
0
        ZVAL_UNDEFINED_OP2();
45362
0
        key = ZSTR_EMPTY_ALLOC();
45363
0
        goto str_index_dim;
45364
5
      } else {
45365
5
        zend_illegal_array_offset_unset(offset);
45366
5
      }
45367
591
      break;
45368
720
    } else if (Z_ISREF_P(container)) {
45369
187
      container = Z_REFVAL_P(container);
45370
187
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45371
187
        goto unset_dim_array;
45372
187
      }
45373
187
    }
45374
533
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45375
384
      container = ZVAL_UNDEFINED_OP1();
45376
384
    }
45377
533
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
45378
0
      offset = ZVAL_UNDEFINED_OP2();
45379
0
    }
45380
533
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45381
82
      if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
45382
44
        offset++;
45383
44
      }
45384
82
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
45385
451
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
45386
7
      zend_throw_error(NULL, "Cannot unset string offsets");
45387
444
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
45388
28
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
45389
416
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
45390
17
      zend_false_to_array_deprecated();
45391
17
    }
45392
533
  } while (0);
45393
45394
45395
1.12k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45396
1.12k
}
45397
45398
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45399
990
{
45400
990
  USE_OPLINE
45401
990
  zval *container;
45402
990
  zval *offset;
45403
990
  zend_string *name, *tmp_name;
45404
45405
990
  SAVE_OPLINE();
45406
990
  container = EX_VAR(opline->op1.var);
45407
990
  offset = RT_CONSTANT(opline, opline->op2);
45408
45409
990
  do {
45410
990
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
45411
220
      if (Z_ISREF_P(container)) {
45412
2
        container = Z_REFVAL_P(container);
45413
2
        if (Z_TYPE_P(container) != IS_OBJECT) {
45414
2
          if (IS_CV == IS_CV
45415
2
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45416
0
            ZVAL_UNDEFINED_OP1();
45417
0
          }
45418
2
          break;
45419
2
        }
45420
218
      } else {
45421
218
        break;
45422
218
      }
45423
220
    }
45424
770
    if (IS_CONST == IS_CONST) {
45425
770
      name = Z_STR_P(offset);
45426
770
    } else {
45427
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
45428
0
      if (UNEXPECTED(!name)) {
45429
0
        break;
45430
0
      }
45431
0
    }
45432
770
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
45433
770
    if (IS_CONST != IS_CONST) {
45434
0
      zend_tmp_string_release(tmp_name);
45435
0
    }
45436
770
  } while (0);
45437
45438
45439
990
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45440
990
}
45441
45442
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45443
1.07k
{
45444
1.07k
  USE_OPLINE
45445
1.07k
  zval *container;
45446
1.07k
  bool result;
45447
1.07k
  zend_ulong hval;
45448
1.07k
  zval *offset;
45449
45450
1.07k
  SAVE_OPLINE();
45451
1.07k
  container = EX_VAR(opline->op1.var);
45452
1.07k
  offset = RT_CONSTANT(opline, opline->op2);
45453
45454
1.07k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45455
247
    HashTable *ht;
45456
247
    zval *value;
45457
247
    zend_string *str;
45458
45459
247
isset_dim_obj_array:
45460
247
    ht = Z_ARRVAL_P(container);
45461
247
isset_again:
45462
247
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45463
52
      str = Z_STR_P(offset);
45464
52
      if (IS_CONST != IS_CONST) {
45465
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
45466
0
          goto num_index_prop;
45467
0
        }
45468
0
      }
45469
52
      value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
45470
195
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45471
165
      hval = Z_LVAL_P(offset);
45472
165
num_index_prop:
45473
165
      value = zend_hash_index_find(ht, hval);
45474
165
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
45475
0
      offset = Z_REFVAL_P(offset);
45476
0
      goto isset_again;
45477
30
    } else {
45478
30
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
45479
30
      if (UNEXPECTED(EG(exception))) {
45480
10
        result = 0;
45481
10
        goto isset_dim_obj_exit;
45482
10
      }
45483
30
    }
45484
45485
237
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
45486
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
45487
223
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
45488
223
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
45489
45490
223
      if (IS_CV & (IS_CONST|IS_CV)) {
45491
        /* avoid exception check */
45492
45493
223
        ZEND_VM_SMART_BRANCH(result, 0);
45494
223
      }
45495
223
    } else {
45496
14
      result = (value == NULL || !i_zend_is_true(value));
45497
14
    }
45498
14
    goto isset_dim_obj_exit;
45499
832
  } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
45500
24
    container = Z_REFVAL_P(container);
45501
24
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45502
0
      goto isset_dim_obj_array;
45503
0
    }
45504
24
  }
45505
45506
832
  if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
45507
187
    offset++;
45508
187
  }
45509
832
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
45510
519
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
45511
519
  } else {
45512
313
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
45513
313
  }
45514
45515
856
isset_dim_obj_exit:
45516
45517
45518
856
  ZEND_VM_SMART_BRANCH(result, 1);
45519
856
}
45520
45521
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45522
526
{
45523
526
  USE_OPLINE
45524
526
  zval *container;
45525
526
  int result;
45526
526
  zval *offset;
45527
526
  zend_string *name, *tmp_name;
45528
45529
526
  SAVE_OPLINE();
45530
526
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
45531
526
  offset = RT_CONSTANT(opline, opline->op2);
45532
45533
526
  if (IS_CV == IS_CONST ||
45534
526
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
45535
263
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
45536
0
      container = Z_REFVAL_P(container);
45537
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
45538
0
        result = (opline->extended_value & ZEND_ISEMPTY);
45539
0
        goto isset_object_finish;
45540
0
      }
45541
263
    } else {
45542
263
      result = (opline->extended_value & ZEND_ISEMPTY);
45543
263
      goto isset_object_finish;
45544
263
    }
45545
263
  }
45546
45547
263
  if (IS_CONST == IS_CONST) {
45548
263
    name = Z_STR_P(offset);
45549
263
  } else {
45550
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
45551
0
    if (UNEXPECTED(!name)) {
45552
0
      result = 0;
45553
0
      goto isset_object_finish;
45554
0
    }
45555
0
  }
45556
45557
263
  result =
45558
263
    (opline->extended_value & ZEND_ISEMPTY) ^
45559
263
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
45560
45561
263
  if (IS_CONST != IS_CONST) {
45562
0
    zend_tmp_string_release(tmp_name);
45563
0
  }
45564
45565
526
isset_object_finish:
45566
45567
45568
526
  ZEND_VM_SMART_BRANCH(result, 1);
45569
526
}
45570
45571
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45572
0
{
45573
0
  USE_OPLINE
45574
45575
0
  zval *key, *subject;
45576
0
  HashTable *ht;
45577
0
  bool result;
45578
45579
0
  SAVE_OPLINE();
45580
45581
0
  key = EX_VAR(opline->op1.var);
45582
0
  subject = RT_CONSTANT(opline, opline->op2);
45583
45584
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
45585
0
array_key_exists_array:
45586
0
    ht = Z_ARRVAL_P(subject);
45587
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
45588
0
  } else {
45589
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
45590
0
      subject = Z_REFVAL_P(subject);
45591
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
45592
0
        goto array_key_exists_array;
45593
0
      }
45594
0
    }
45595
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
45596
0
    result = 0;
45597
0
  }
45598
45599
45600
0
  ZEND_VM_SMART_BRANCH(result, 1);
45601
0
}
45602
45603
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45604
190
{
45605
190
  USE_OPLINE
45606
190
  zval *expr;
45607
190
  bool result;
45608
45609
190
  SAVE_OPLINE();
45610
190
  expr = EX_VAR(opline->op1.var);
45611
45612
221
try_instanceof:
45613
221
  if (Z_TYPE_P(expr) == IS_OBJECT) {
45614
141
    zend_class_entry *ce;
45615
45616
141
    if (IS_CONST == IS_CONST) {
45617
141
      ce = CACHED_PTR(opline->extended_value);
45618
141
      if (UNEXPECTED(ce == NULL)) {
45619
36
        ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD);
45620
36
        if (EXPECTED(ce)) {
45621
29
          CACHE_PTR(opline->extended_value, ce);
45622
29
        }
45623
36
      }
45624
141
    } else if (IS_CONST == IS_UNUSED) {
45625
0
      ce = zend_fetch_class(NULL, opline->op2.num);
45626
0
      if (UNEXPECTED(ce == NULL)) {
45627
45628
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
45629
0
        HANDLE_EXCEPTION();
45630
0
      }
45631
0
    } else {
45632
0
      ce = Z_CE_P(EX_VAR(opline->op2.var));
45633
0
    }
45634
141
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
45635
141
  } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
45636
31
    expr = Z_REFVAL_P(expr);
45637
31
    goto try_instanceof;
45638
49
  } else {
45639
49
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
45640
5
      ZVAL_UNDEFINED_OP1();
45641
5
    }
45642
49
    result = 0;
45643
49
  }
45644
45645
190
  ZEND_VM_SMART_BRANCH(result, 1);
45646
190
}
45647
45648
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45649
0
{
45650
0
  USE_OPLINE
45651
45652
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
45653
45654
0
  SAVE_OPLINE();
45655
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
45656
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45657
0
  }
45658
45659
  /* Destroy the previously yielded value */
45660
0
  zval_ptr_dtor(&generator->value);
45661
45662
  /* Destroy the previously yielded key */
45663
0
  zval_ptr_dtor(&generator->key);
45664
45665
  /* Set the new yielded value */
45666
0
  if (IS_CV != IS_UNUSED) {
45667
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
45668
      /* Constants and temporary variables aren't yieldable by reference,
45669
       * but we still allow them with a notice. */
45670
0
      if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
45671
0
        zval *value;
45672
45673
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
45674
45675
0
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45676
0
        ZVAL_COPY_VALUE(&generator->value, value);
45677
0
        if (IS_CV == IS_CONST) {
45678
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
45679
0
            Z_ADDREF(generator->value);
45680
0
          }
45681
0
        }
45682
0
      } else {
45683
0
        zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45684
45685
        /* If a function call result is yielded and the function did
45686
         * not return by reference we throw a notice. */
45687
0
        do {
45688
0
          if (IS_CV == IS_VAR) {
45689
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
45690
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
45691
0
             && !Z_ISREF_P(value_ptr)) {
45692
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
45693
0
              ZVAL_COPY(&generator->value, value_ptr);
45694
0
              break;
45695
0
            }
45696
0
          }
45697
0
          if (Z_ISREF_P(value_ptr)) {
45698
0
            Z_ADDREF_P(value_ptr);
45699
0
          } else {
45700
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
45701
0
          }
45702
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
45703
0
        } while (0);
45704
45705
0
      }
45706
0
    } else {
45707
0
      zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45708
45709
      /* Consts, temporary variables and references need copying */
45710
0
      if (IS_CV == IS_CONST) {
45711
0
        ZVAL_COPY_VALUE(&generator->value, value);
45712
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
45713
0
          Z_ADDREF(generator->value);
45714
0
        }
45715
0
      } else if (IS_CV == IS_TMP_VAR) {
45716
0
        ZVAL_COPY_VALUE(&generator->value, value);
45717
0
      } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
45718
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
45719
45720
0
      } else {
45721
0
        ZVAL_COPY_VALUE(&generator->value, value);
45722
0
        if (IS_CV == IS_CV) {
45723
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
45724
0
        }
45725
0
      }
45726
0
    }
45727
0
  } else {
45728
    /* If no value was specified yield null */
45729
0
    ZVAL_NULL(&generator->value);
45730
0
  }
45731
45732
  /* Set the new yielded key */
45733
0
  if (IS_CONST != IS_UNUSED) {
45734
0
    zval *key = RT_CONSTANT(opline, opline->op2);
45735
0
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
45736
0
      key = Z_REFVAL_P(key);
45737
0
    }
45738
0
    ZVAL_COPY(&generator->key, key);
45739
45740
0
    if (Z_TYPE(generator->key) == IS_LONG
45741
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
45742
0
    ) {
45743
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
45744
0
    }
45745
0
  } else {
45746
    /* If no key was specified we use auto-increment keys */
45747
0
    generator->largest_used_integer_key++;
45748
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
45749
0
  }
45750
45751
0
  if (RETURN_VALUE_USED(opline)) {
45752
    /* If the return value of yield is used set the send
45753
     * target and initialize it to NULL */
45754
0
    generator->send_target = EX_VAR(opline->result.var);
45755
0
    ZVAL_NULL(generator->send_target);
45756
0
  } else {
45757
0
    generator->send_target = NULL;
45758
0
  }
45759
45760
  /* The GOTO VM uses a local opline variable. We need to set the opline
45761
   * variable in execute_data so we don't resume at an old position. */
45762
0
  SAVE_OPLINE();
45763
45764
0
  ZEND_VM_RETURN();
45765
0
}
45766
45767
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45768
2.69k
{
45769
2.69k
  USE_OPLINE
45770
2.69k
  zend_string *varname;
45771
2.69k
  zval *value;
45772
2.69k
  zval *variable_ptr;
45773
2.69k
  uintptr_t idx;
45774
2.69k
  zend_reference *ref;
45775
45776
2.73k
  ZEND_VM_REPEATABLE_OPCODE
45777
45778
2.73k
  varname = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45779
45780
  /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45781
2.73k
  idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
45782
2.73k
  if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
45783
2.03k
    Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
45784
45785
2.03k
    if (EXPECTED(p->key == varname) ||
45786
2.03k
        (EXPECTED(p->h == ZSTR_H(varname)) &&
45787
0
         EXPECTED(p->key != NULL) &&
45788
2.03k
         EXPECTED(zend_string_equal_content(p->key, varname)))) {
45789
45790
2.03k
      value = (zval*)p; /* value = &p->val; */
45791
2.03k
      goto check_indirect;
45792
2.03k
    }
45793
2.03k
  }
45794
45795
692
  value = zend_hash_find_known_hash(&EG(symbol_table), varname);
45796
692
  if (UNEXPECTED(value == NULL)) {
45797
142
    value = zend_hash_add_new(&EG(symbol_table), varname, &EG(uninitialized_zval));
45798
142
    idx = (char*)value - (char*)EG(symbol_table).arData;
45799
    /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45800
142
    CACHE_PTR(opline->extended_value, (void*)(idx + 1));
45801
550
  } else {
45802
550
    idx = (char*)value - (char*)EG(symbol_table).arData;
45803
    /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45804
550
    CACHE_PTR(opline->extended_value, (void*)(idx + 1));
45805
2.58k
check_indirect:
45806
    /* GLOBAL variable may be an INDIRECT pointer to CV */
45807
2.58k
    if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
45808
1.56k
      value = Z_INDIRECT_P(value);
45809
1.56k
      if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
45810
77
        ZVAL_NULL(value);
45811
77
      }
45812
1.56k
    }
45813
2.58k
  }
45814
45815
2.73k
  if (UNEXPECTED(!Z_ISREF_P(value))) {
45816
578
    ZVAL_MAKE_REF_EX(value, 2);
45817
578
    ref = Z_REF_P(value);
45818
2.15k
  } else {
45819
2.15k
    ref = Z_REF_P(value);
45820
2.15k
    GC_ADDREF(ref);
45821
2.15k
  }
45822
45823
2.73k
  variable_ptr = EX_VAR(opline->op1.var);
45824
45825
2.73k
  if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
45826
39
    zend_refcounted *garbage = Z_COUNTED_P(variable_ptr);
45827
45828
39
    ZVAL_REF(variable_ptr, ref);
45829
39
    SAVE_OPLINE();
45830
39
    if (GC_DELREF(garbage) == 0) {
45831
0
      rc_dtor_func(garbage);
45832
0
      if (UNEXPECTED(EG(exception))) {
45833
0
        ZVAL_NULL(variable_ptr);
45834
0
        HANDLE_EXCEPTION();
45835
0
      }
45836
39
    } else {
45837
39
      gc_check_possible_root(garbage);
45838
39
    }
45839
2.69k
  } else {
45840
2.69k
    ZVAL_REF(variable_ptr, ref);
45841
2.69k
  }
45842
45843
2.73k
  ZEND_VM_REPEAT_OPCODE(ZEND_BIND_GLOBAL);
45844
0
  ZEND_VM_NEXT_OPCODE();
45845
0
}
45846
45847
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45848
13
{
45849
13
  USE_OPLINE
45850
13
  zval *op1;
45851
13
  HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
45852
13
  zval *result;
45853
45854
13
  op1 = EX_VAR(opline->op1.var);
45855
13
  if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45856
11
    result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CV == IS_CONST);
45857
11
    if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45858
0
      zval_ptr_dtor_str(op1);
45859
0
    }
45860
11
    ZEND_VM_SMART_BRANCH(result, 0);
45861
11
  }
45862
45863
2
  if (opline->extended_value) {
45864
0
    if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45865
0
      result = zend_hash_index_find(ht, Z_LVAL_P(op1));
45866
0
      ZEND_VM_SMART_BRANCH(result, 0);
45867
0
    }
45868
0
    SAVE_OPLINE();
45869
0
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
45870
0
      op1 = Z_REFVAL_P(op1);
45871
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45872
0
        result = zend_hash_find(ht, Z_STR_P(op1));
45873
45874
0
        ZEND_VM_SMART_BRANCH(result, 0);
45875
0
      } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45876
0
        result = zend_hash_index_find(ht, Z_LVAL_P(op1));
45877
45878
0
        ZEND_VM_SMART_BRANCH(result, 0);
45879
0
      }
45880
0
    } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
45881
0
      ZVAL_UNDEFINED_OP1();
45882
0
    }
45883
2
  } else if (Z_TYPE_P(op1) <= IS_FALSE) {
45884
2
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
45885
2
      SAVE_OPLINE();
45886
2
      ZVAL_UNDEFINED_OP1();
45887
2
      if (UNEXPECTED(EG(exception) != NULL)) {
45888
0
        HANDLE_EXCEPTION();
45889
0
      }
45890
2
    }
45891
2
    result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
45892
2
    ZEND_VM_SMART_BRANCH(result, 0);
45893
2
  } else {
45894
0
    zend_string *key;
45895
0
    zval key_tmp;
45896
45897
0
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
45898
0
      op1 = Z_REFVAL_P(op1);
45899
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45900
0
        result = zend_hash_find(ht, Z_STR_P(op1));
45901
45902
0
        ZEND_VM_SMART_BRANCH(result, 0);
45903
0
      }
45904
0
    }
45905
45906
0
    SAVE_OPLINE();
45907
0
    ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
45908
0
      ZVAL_STR(&key_tmp, key);
45909
0
      if (zend_compare(op1, &key_tmp) == 0) {
45910
45911
0
        ZEND_VM_SMART_BRANCH(1, 1);
45912
0
      }
45913
0
    } ZEND_HASH_FOREACH_END();
45914
0
  }
45915
45916
0
  ZEND_VM_SMART_BRANCH(0, 1);
45917
0
}
45918
45919
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45920
1.20k
{
45921
  /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
45922
  /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
45923
  /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
45924
1.20k
  USE_OPLINE
45925
1.20k
  zval *op1, *op2;
45926
1.20k
  bool result;
45927
45928
1.20k
  op1 = EX_VAR(opline->op1.var);
45929
1.20k
  op2 = RT_CONSTANT(opline, opline->op2);
45930
1.20k
  result = fast_is_identical_function(op1, op2);
45931
  /* Free is a no-op for const/cv */
45932
1.20k
  ZEND_VM_SMART_BRANCH(result, 0);
45933
1.20k
}
45934
45935
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45936
79
{
45937
79
  USE_OPLINE
45938
79
  zval *op1, *op2;
45939
79
  bool result;
45940
45941
79
  op1 = EX_VAR(opline->op1.var);
45942
79
  op2 = RT_CONSTANT(opline, opline->op2);
45943
79
  result = fast_is_identical_function(op1, op2);
45944
  /* Free is a no-op for const/cv */
45945
79
  ZEND_VM_SMART_BRANCH(!result, 0);
45946
79
}
45947
45948
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45949
3.43k
{
45950
3.43k
  USE_OPLINE
45951
3.43k
  zval *container, *dim, *value;
45952
3.43k
  zend_long offset;
45953
3.43k
  HashTable *ht;
45954
45955
3.43k
  container = EX_VAR(opline->op1.var);
45956
3.43k
  dim = RT_CONSTANT(opline, opline->op2);
45957
3.43k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45958
1.43k
fetch_dim_r_index_array:
45959
1.43k
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
45960
1.39k
      offset = Z_LVAL_P(dim);
45961
1.39k
    } else {
45962
37
      SAVE_OPLINE();
45963
37
      zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
45964
45965
37
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45966
37
    }
45967
1.39k
    ht = Z_ARRVAL_P(container);
45968
1.39k
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
45969
1.31k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
45970
1.31k
    if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45971
0
      SAVE_OPLINE();
45972
45973
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45974
1.31k
    } else {
45975
1.31k
      ZEND_VM_NEXT_OPCODE();
45976
1.31k
    }
45977
2.04k
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
45978
47
    container = Z_REFVAL_P(container);
45979
47
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45980
38
      goto fetch_dim_r_index_array;
45981
38
    } else {
45982
9
      goto fetch_dim_r_index_slow;
45983
9
    }
45984
1.99k
  } else {
45985
2.00k
fetch_dim_r_index_slow:
45986
2.00k
    SAVE_OPLINE();
45987
2.00k
    if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45988
55
      dim++;
45989
55
    }
45990
2.00k
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45991
45992
2.00k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45993
2.00k
  }
45994
45995
79
fetch_dim_r_index_undef:
45996
79
  ZVAL_NULL(EX_VAR(opline->result.var));
45997
79
  SAVE_OPLINE();
45998
79
  zend_undefined_offset(offset);
45999
46000
79
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46001
79
}
46002
46003
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46004
2.53k
{
46005
2.53k
  USE_OPLINE
46006
2.53k
  zval *container, *dim, *value;
46007
2.53k
  zend_long offset;
46008
2.53k
  HashTable *ht;
46009
46010
2.53k
  container = EX_VAR(opline->op1.var);
46011
2.53k
  dim = EX_VAR(opline->op2.var);
46012
2.53k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46013
1.75k
fetch_dim_r_index_array:
46014
1.75k
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
46015
1.64k
      offset = Z_LVAL_P(dim);
46016
1.64k
    } else {
46017
105
      SAVE_OPLINE();
46018
105
      zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
46019
46020
105
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46021
105
    }
46022
1.64k
    ht = Z_ARRVAL_P(container);
46023
1.64k
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
46024
1.61k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46025
1.61k
    if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46026
0
      SAVE_OPLINE();
46027
46028
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46029
1.61k
    } else {
46030
1.61k
      ZEND_VM_NEXT_OPCODE();
46031
1.61k
    }
46032
1.61k
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
46033
0
    container = Z_REFVAL_P(container);
46034
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46035
0
      goto fetch_dim_r_index_array;
46036
0
    } else {
46037
0
      goto fetch_dim_r_index_slow;
46038
0
    }
46039
787
  } else {
46040
787
fetch_dim_r_index_slow:
46041
787
    SAVE_OPLINE();
46042
787
    if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46043
0
      dim++;
46044
0
    }
46045
787
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46046
46047
787
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46048
787
  }
46049
46050
34
fetch_dim_r_index_undef:
46051
34
  ZVAL_NULL(EX_VAR(opline->result.var));
46052
34
  SAVE_OPLINE();
46053
34
  zend_undefined_offset(offset);
46054
46055
34
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46056
34
}
46057
46058
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46059
418
{
46060
418
  USE_OPLINE
46061
418
  zval *op1, *op2;
46062
46063
418
  SAVE_OPLINE();
46064
418
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46065
418
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46066
418
  div_function(EX_VAR(opline->result.var), op1, op2);
46067
46068
418
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46069
418
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46070
418
}
46071
46072
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46073
0
{
46074
0
  USE_OPLINE
46075
0
  zval *op1, *op2;
46076
46077
0
  SAVE_OPLINE();
46078
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46079
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46080
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
46081
46082
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46083
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46084
0
}
46085
46086
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46087
294k
{
46088
294k
  USE_OPLINE
46089
294k
  zval *op1, *op2;
46090
46091
294k
  op1 = EX_VAR(opline->op1.var);
46092
294k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46093
46094
294k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
46095
294k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
46096
273k
    zend_string *op1_str = Z_STR_P(op1);
46097
273k
    zend_string *op2_str = Z_STR_P(op2);
46098
273k
    zend_string *str;
46099
273k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
46100
46101
273k
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
46102
581
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
46103
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
46104
581
      } else {
46105
581
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
46106
581
      }
46107
581
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46108
0
        zend_string_release_ex(op1_str, 0);
46109
0
      }
46110
272k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
46111
358
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
46112
358
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
46113
358
      } else {
46114
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
46115
0
      }
46116
358
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46117
358
        zend_string_release_ex(op2_str, 0);
46118
358
      }
46119
272k
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
46120
272k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
46121
0
      size_t len = ZSTR_LEN(op1_str);
46122
46123
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
46124
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
46125
0
      }
46126
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
46127
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
46128
0
      GC_ADD_FLAGS(str, flags);
46129
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
46130
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46131
0
        zend_string_release_ex(op2_str, 0);
46132
0
      }
46133
272k
    } else {
46134
272k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
46135
272k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
46136
272k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
46137
272k
      GC_ADD_FLAGS(str, flags);
46138
272k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
46139
272k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46140
0
        zend_string_release_ex(op1_str, 0);
46141
0
      }
46142
272k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46143
272k
        zend_string_release_ex(op2_str, 0);
46144
272k
      }
46145
272k
    }
46146
273k
    ZEND_VM_NEXT_OPCODE();
46147
273k
  } else {
46148
21.4k
    SAVE_OPLINE();
46149
46150
21.4k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
46151
14.9k
      op1 = ZVAL_UNDEFINED_OP1();
46152
14.9k
    }
46153
21.4k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
46154
0
      op2 = ZVAL_UNDEFINED_OP2();
46155
0
    }
46156
21.4k
    concat_function(EX_VAR(opline->result.var), op1, op2);
46157
46158
21.4k
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46159
21.4k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46160
21.4k
  }
46161
294k
}
46162
46163
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46164
6.87k
{
46165
6.87k
  USE_OPLINE
46166
6.87k
  zval *op1, *op2;
46167
6.87k
  double d1, d2;
46168
46169
6.87k
  op1 = EX_VAR(opline->op1.var);
46170
6.87k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46171
6.87k
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46172
    /* pass */
46173
6.87k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46174
3.68k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46175
2.35k
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46176
195
is_equal_true:
46177
195
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
46178
2.17k
      } else {
46179
2.80k
is_equal_false:
46180
2.80k
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
46181
2.80k
      }
46182
2.35k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46183
0
      d1 = (double)Z_LVAL_P(op1);
46184
0
      d2 = Z_DVAL_P(op2);
46185
0
      goto is_equal_double;
46186
0
    }
46187
3.68k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46188
745
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46189
3
      d1 = Z_DVAL_P(op1);
46190
3
      d2 = Z_DVAL_P(op2);
46191
550
is_equal_double:
46192
550
      if (d1 == d2) {
46193
3
        goto is_equal_true;
46194
547
      } else {
46195
547
        goto is_equal_false;
46196
547
      }
46197
742
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46198
547
      d1 = Z_DVAL_P(op1);
46199
547
      d2 = (double)Z_LVAL_P(op2);
46200
547
      goto is_equal_double;
46201
547
    }
46202
2.44k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46203
636
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46204
96
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46205
96
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46206
0
        zval_ptr_dtor_str(op1);
46207
0
      }
46208
96
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46209
96
        zval_ptr_dtor_str(op2);
46210
96
      }
46211
96
      if (result) {
46212
13
        goto is_equal_true;
46213
83
      } else {
46214
83
        goto is_equal_false;
46215
83
      }
46216
96
    }
46217
636
  }
46218
6.87k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46219
6.87k
}
46220
46221
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46222
273
{
46223
273
  USE_OPLINE
46224
273
  zval *op1, *op2;
46225
273
  double d1, d2;
46226
46227
273
  op1 = EX_VAR(opline->op1.var);
46228
273
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46229
273
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46230
    /* pass */
46231
273
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46232
139
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46233
134
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46234
15
is_equal_true:
46235
15
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
46236
122
      } else {
46237
131
is_equal_false:
46238
131
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
46239
131
      }
46240
134
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46241
0
      d1 = (double)Z_LVAL_P(op1);
46242
0
      d2 = Z_DVAL_P(op2);
46243
0
      goto is_equal_double;
46244
0
    }
46245
139
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46246
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46247
0
      d1 = Z_DVAL_P(op1);
46248
0
      d2 = Z_DVAL_P(op2);
46249
0
is_equal_double:
46250
0
      if (d1 == d2) {
46251
0
        goto is_equal_true;
46252
0
      } else {
46253
0
        goto is_equal_false;
46254
0
      }
46255
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46256
0
      d1 = Z_DVAL_P(op1);
46257
0
      d2 = (double)Z_LVAL_P(op2);
46258
0
      goto is_equal_double;
46259
0
    }
46260
134
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46261
27
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46262
12
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46263
12
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46264
0
        zval_ptr_dtor_str(op1);
46265
0
      }
46266
12
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46267
12
        zval_ptr_dtor_str(op2);
46268
12
      }
46269
12
      if (result) {
46270
3
        goto is_equal_true;
46271
9
      } else {
46272
9
        goto is_equal_false;
46273
9
      }
46274
12
    }
46275
27
  }
46276
273
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46277
273
}
46278
46279
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46280
186
{
46281
186
  USE_OPLINE
46282
186
  zval *op1, *op2;
46283
186
  double d1, d2;
46284
46285
186
  op1 = EX_VAR(opline->op1.var);
46286
186
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46287
186
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46288
    /* pass */
46289
186
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46290
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46291
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46292
0
is_equal_true:
46293
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
46294
0
      } else {
46295
0
is_equal_false:
46296
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
46297
0
      }
46298
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46299
0
      d1 = (double)Z_LVAL_P(op1);
46300
0
      d2 = Z_DVAL_P(op2);
46301
0
      goto is_equal_double;
46302
0
    }
46303
186
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46304
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46305
0
      d1 = Z_DVAL_P(op1);
46306
0
      d2 = Z_DVAL_P(op2);
46307
0
is_equal_double:
46308
0
      if (d1 == d2) {
46309
0
        goto is_equal_true;
46310
0
      } else {
46311
0
        goto is_equal_false;
46312
0
      }
46313
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46314
0
      d1 = Z_DVAL_P(op1);
46315
0
      d2 = (double)Z_LVAL_P(op2);
46316
0
      goto is_equal_double;
46317
0
    }
46318
186
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46319
168
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46320
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46321
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46322
0
        zval_ptr_dtor_str(op1);
46323
0
      }
46324
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46325
0
        zval_ptr_dtor_str(op2);
46326
0
      }
46327
0
      if (result) {
46328
0
        goto is_equal_true;
46329
0
      } else {
46330
0
        goto is_equal_false;
46331
0
      }
46332
0
    }
46333
168
  }
46334
186
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46335
186
}
46336
46337
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46338
11.9k
{
46339
11.9k
  USE_OPLINE
46340
11.9k
  zval *op1, *op2;
46341
11.9k
  double d1, d2;
46342
46343
11.9k
  op1 = EX_VAR(opline->op1.var);
46344
11.9k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46345
11.9k
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46346
    /* pass */
46347
11.9k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46348
1.49k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46349
987
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46350
1.49k
is_not_equal_true:
46351
1.49k
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
46352
1.49k
      } else {
46353
291
is_not_equal_false:
46354
291
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
46355
291
      }
46356
987
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46357
28
      d1 = (double)Z_LVAL_P(op1);
46358
28
      d2 = Z_DVAL_P(op2);
46359
28
      goto is_not_equal_double;
46360
28
    }
46361
10.4k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46362
263
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46363
211
      d1 = Z_DVAL_P(op1);
46364
211
      d2 = Z_DVAL_P(op2);
46365
243
is_not_equal_double:
46366
243
      if (d1 != d2) {
46367
91
        goto is_not_equal_true;
46368
152
      } else {
46369
152
        goto is_not_equal_false;
46370
152
      }
46371
243
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46372
4
      d1 = Z_DVAL_P(op1);
46373
4
      d2 = (double)Z_LVAL_P(op2);
46374
4
      goto is_not_equal_double;
46375
4
    }
46376
10.1k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46377
1.40k
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46378
555
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46379
555
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46380
0
        zval_ptr_dtor_str(op1);
46381
0
      }
46382
555
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46383
555
        zval_ptr_dtor_str(op2);
46384
555
      }
46385
555
      if (!result) {
46386
507
        goto is_not_equal_true;
46387
507
      } else {
46388
48
        goto is_not_equal_false;
46389
48
      }
46390
555
    }
46391
1.40k
  }
46392
11.9k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46393
11.9k
}
46394
46395
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46396
150
{
46397
150
  USE_OPLINE
46398
150
  zval *op1, *op2;
46399
150
  double d1, d2;
46400
46401
150
  op1 = EX_VAR(opline->op1.var);
46402
150
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46403
150
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46404
    /* pass */
46405
150
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46406
69
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46407
26
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46408
16
is_not_equal_true:
46409
16
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
46410
16
      } else {
46411
17
is_not_equal_false:
46412
17
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
46413
17
      }
46414
43
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46415
0
      d1 = (double)Z_LVAL_P(op1);
46416
0
      d2 = Z_DVAL_P(op2);
46417
0
      goto is_not_equal_double;
46418
0
    }
46419
81
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46420
7
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46421
7
      d1 = Z_DVAL_P(op1);
46422
7
      d2 = Z_DVAL_P(op2);
46423
7
is_not_equal_double:
46424
7
      if (d1 != d2) {
46425
0
        goto is_not_equal_true;
46426
7
      } else {
46427
7
        goto is_not_equal_false;
46428
7
      }
46429
7
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46430
0
      d1 = Z_DVAL_P(op1);
46431
0
      d2 = (double)Z_LVAL_P(op2);
46432
0
      goto is_not_equal_double;
46433
0
    }
46434
74
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46435
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46436
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46437
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46438
0
        zval_ptr_dtor_str(op1);
46439
0
      }
46440
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46441
0
        zval_ptr_dtor_str(op2);
46442
0
      }
46443
0
      if (!result) {
46444
0
        goto is_not_equal_true;
46445
0
      } else {
46446
0
        goto is_not_equal_false;
46447
0
      }
46448
0
    }
46449
0
  }
46450
150
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46451
150
}
46452
46453
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46454
6
{
46455
6
  USE_OPLINE
46456
6
  zval *op1, *op2;
46457
6
  double d1, d2;
46458
46459
6
  op1 = EX_VAR(opline->op1.var);
46460
6
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46461
6
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46462
    /* pass */
46463
6
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46464
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46465
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46466
0
is_not_equal_true:
46467
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
46468
0
      } else {
46469
0
is_not_equal_false:
46470
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
46471
0
      }
46472
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46473
0
      d1 = (double)Z_LVAL_P(op1);
46474
0
      d2 = Z_DVAL_P(op2);
46475
0
      goto is_not_equal_double;
46476
0
    }
46477
6
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46478
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46479
0
      d1 = Z_DVAL_P(op1);
46480
0
      d2 = Z_DVAL_P(op2);
46481
0
is_not_equal_double:
46482
0
      if (d1 != d2) {
46483
0
        goto is_not_equal_true;
46484
0
      } else {
46485
0
        goto is_not_equal_false;
46486
0
      }
46487
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46488
0
      d1 = Z_DVAL_P(op1);
46489
0
      d2 = (double)Z_LVAL_P(op2);
46490
0
      goto is_not_equal_double;
46491
0
    }
46492
6
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46493
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46494
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46495
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46496
0
        zval_ptr_dtor_str(op1);
46497
0
      }
46498
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46499
0
        zval_ptr_dtor_str(op2);
46500
0
      }
46501
0
      if (!result) {
46502
0
        goto is_not_equal_true;
46503
0
      } else {
46504
0
        goto is_not_equal_false;
46505
0
      }
46506
0
    }
46507
0
  }
46508
6
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46509
6
}
46510
46511
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46512
0
{
46513
0
  USE_OPLINE
46514
0
  zval *op1, *op2;
46515
46516
0
  SAVE_OPLINE();
46517
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46518
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46519
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
46520
46521
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46522
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46523
0
}
46524
46525
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46526
0
{
46527
0
  USE_OPLINE
46528
0
  zval *op1, *op2;
46529
46530
0
  SAVE_OPLINE();
46531
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46532
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46533
0
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
46534
46535
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46536
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46537
0
}
46538
46539
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46540
0
{
46541
0
  USE_OPLINE
46542
0
  zval *object;
46543
0
  zval *property;
46544
0
  zval *value;
46545
0
  zval *zptr;
46546
0
  void *_cache_slot[3] = {0};
46547
0
  void **cache_slot;
46548
0
  zend_property_info *prop_info;
46549
0
  zend_object *zobj;
46550
0
  zend_string *name, *tmp_name;
46551
46552
0
  SAVE_OPLINE();
46553
0
  object = EX_VAR(opline->op1.var);
46554
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46555
46556
0
  do {
46557
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
46558
46559
0
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46560
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46561
0
        object = Z_REFVAL_P(object);
46562
0
        goto assign_op_object;
46563
0
      }
46564
0
      if (IS_CV == IS_CV
46565
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46566
0
        ZVAL_UNDEFINED_OP1();
46567
0
      }
46568
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46569
0
      break;
46570
0
    }
46571
46572
0
assign_op_object:
46573
    /* here we are sure we are dealing with an object */
46574
0
    zobj = Z_OBJ_P(object);
46575
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46576
0
      name = Z_STR_P(property);
46577
0
    } else {
46578
0
      name = zval_try_get_tmp_string(property, &tmp_name);
46579
0
      if (UNEXPECTED(!name)) {
46580
0
        UNDEF_RESULT();
46581
0
        break;
46582
0
      }
46583
0
    }
46584
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
46585
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46586
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46587
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46588
0
          ZVAL_NULL(EX_VAR(opline->result.var));
46589
0
        }
46590
0
      } else {
46591
0
        zend_reference *ref;
46592
46593
0
        do {
46594
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
46595
0
            ref = Z_REF_P(zptr);
46596
0
            zptr = Z_REFVAL_P(zptr);
46597
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46598
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46599
0
              break;
46600
0
            }
46601
0
          }
46602
46603
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
46604
0
          if (prop_info) {
46605
            /* special case for typed properties */
46606
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
46607
0
          } else {
46608
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
46609
0
          }
46610
0
        } while (0);
46611
46612
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46613
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
46614
0
        }
46615
0
      }
46616
0
    } else {
46617
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
46618
0
    }
46619
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46620
0
      zend_tmp_string_release(tmp_name);
46621
0
    }
46622
0
  } while (0);
46623
46624
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46625
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46626
46627
  /* assign_obj has two opcodes! */
46628
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
46629
0
}
46630
46631
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
46632
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46633
714
{
46634
714
  USE_OPLINE
46635
714
  zval *var_ptr;
46636
714
  zval *value, *container, *dim;
46637
714
  HashTable *ht;
46638
46639
714
  SAVE_OPLINE();
46640
714
  container = EX_VAR(opline->op1.var);
46641
46642
714
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46643
527
assign_dim_op_array:
46644
527
    SEPARATE_ARRAY(container);
46645
527
    ht = Z_ARRVAL_P(container);
46646
709
assign_dim_op_new_array:
46647
709
    dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46648
709
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46649
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
46650
0
      if (UNEXPECTED(!var_ptr)) {
46651
0
        zend_cannot_add_element();
46652
0
        goto assign_dim_op_ret_null;
46653
0
      }
46654
709
    } else {
46655
709
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46656
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
46657
709
      } else {
46658
709
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
46659
709
      }
46660
709
      if (UNEXPECTED(!var_ptr)) {
46661
5
        goto assign_dim_op_ret_null;
46662
5
      }
46663
709
    }
46664
46665
704
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
46666
46667
704
    do {
46668
704
      if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
46669
0
        zend_reference *ref = Z_REF_P(var_ptr);
46670
0
        var_ptr = Z_REFVAL_P(var_ptr);
46671
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46672
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46673
0
          break;
46674
0
        }
46675
0
      }
46676
704
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
46677
704
    } while (0);
46678
46679
704
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46680
349
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
46681
349
    }
46682
704
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46683
704
  } else {
46684
187
    if (EXPECTED(Z_ISREF_P(container))) {
46685
0
      container = Z_REFVAL_P(container);
46686
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46687
0
        goto assign_dim_op_array;
46688
0
      }
46689
0
    }
46690
46691
187
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
46692
5
      zend_object *obj = Z_OBJ_P(container);
46693
46694
5
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46695
5
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46696
0
        dim++;
46697
0
      }
46698
5
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
46699
182
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
46700
182
      uint8_t old_type;
46701
46702
182
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
46703
182
        ZVAL_UNDEFINED_OP1();
46704
182
      }
46705
182
      ht = zend_new_array(8);
46706
182
      old_type = Z_TYPE_P(container);
46707
182
      ZVAL_ARR(container, ht);
46708
182
      if (UNEXPECTED(old_type == IS_FALSE)) {
46709
0
        GC_ADDREF(ht);
46710
0
        zend_false_to_array_deprecated();
46711
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46712
0
          zend_array_destroy(ht);
46713
0
          goto assign_dim_op_ret_null;
46714
0
        }
46715
0
      }
46716
182
      goto assign_dim_op_new_array;
46717
182
    } else {
46718
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46719
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46720
5
assign_dim_op_ret_null:
46721
5
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46722
5
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46723
5
        ZVAL_NULL(EX_VAR(opline->result.var));
46724
5
      }
46725
5
    }
46726
187
  }
46727
46728
714
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46729
46730
714
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
46731
714
}
46732
46733
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46734
2.23M
{
46735
2.23M
  USE_OPLINE
46736
2.23M
  zval *var_ptr;
46737
2.23M
  zval *value;
46738
46739
2.23M
  SAVE_OPLINE();
46740
2.23M
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46741
2.23M
  var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
46742
46743
2.23M
  do {
46744
2.23M
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
46745
3.40k
      zend_reference *ref = Z_REF_P(var_ptr);
46746
3.40k
      var_ptr = Z_REFVAL_P(var_ptr);
46747
3.40k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46748
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46749
0
        break;
46750
0
      }
46751
3.40k
    }
46752
2.23M
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
46753
2.23M
  } while (0);
46754
46755
2.23M
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46756
1.62M
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
46757
1.62M
  }
46758
46759
2.23M
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46760
46761
2.23M
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46762
2.23M
}
46763
46764
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46765
0
{
46766
0
  USE_OPLINE
46767
0
  zval *object;
46768
0
  zval *property;
46769
0
  zval *zptr;
46770
0
  void *_cache_slot[3] = {0};
46771
0
  void **cache_slot;
46772
0
  zend_property_info *prop_info;
46773
0
  zend_object *zobj;
46774
0
  zend_string *name, *tmp_name;
46775
46776
0
  SAVE_OPLINE();
46777
0
  object = EX_VAR(opline->op1.var);
46778
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46779
46780
0
  do {
46781
0
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46782
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46783
0
        object = Z_REFVAL_P(object);
46784
0
        goto pre_incdec_object;
46785
0
      }
46786
0
      if (IS_CV == IS_CV
46787
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46788
0
        ZVAL_UNDEFINED_OP1();
46789
0
      }
46790
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46791
0
      break;
46792
0
    }
46793
46794
0
pre_incdec_object:
46795
    /* here we are sure we are dealing with an object */
46796
0
    zobj = Z_OBJ_P(object);
46797
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46798
0
      name = Z_STR_P(property);
46799
0
    } else {
46800
0
      name = zval_try_get_tmp_string(property, &tmp_name);
46801
0
      if (UNEXPECTED(!name)) {
46802
0
        UNDEF_RESULT();
46803
0
        break;
46804
0
      }
46805
0
    }
46806
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
46807
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46808
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46809
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46810
0
          ZVAL_NULL(EX_VAR(opline->result.var));
46811
0
        }
46812
0
      } else {
46813
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
46814
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
46815
0
      }
46816
0
    } else {
46817
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
46818
0
    }
46819
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46820
0
      zend_tmp_string_release(tmp_name);
46821
0
    }
46822
0
  } while (0);
46823
46824
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46825
46826
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46827
0
}
46828
46829
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46830
0
{
46831
0
  USE_OPLINE
46832
0
  zval *object;
46833
0
  zval *property;
46834
0
  zval *zptr;
46835
0
  void *_cache_slot[3] = {0};
46836
0
  void **cache_slot;
46837
0
  zend_property_info *prop_info;
46838
0
  zend_object *zobj;
46839
0
  zend_string *name, *tmp_name;
46840
46841
0
  SAVE_OPLINE();
46842
0
  object = EX_VAR(opline->op1.var);
46843
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46844
46845
0
  do {
46846
0
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46847
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46848
0
        object = Z_REFVAL_P(object);
46849
0
        goto post_incdec_object;
46850
0
      }
46851
0
      if (IS_CV == IS_CV
46852
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46853
0
        ZVAL_UNDEFINED_OP1();
46854
0
      }
46855
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46856
0
      break;
46857
0
    }
46858
46859
0
post_incdec_object:
46860
    /* here we are sure we are dealing with an object */
46861
0
    zobj = Z_OBJ_P(object);
46862
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46863
0
      name = Z_STR_P(property);
46864
0
    } else {
46865
0
      name = zval_try_get_tmp_string(property, &tmp_name);
46866
0
      if (UNEXPECTED(!name)) {
46867
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
46868
0
        break;
46869
0
      }
46870
0
    }
46871
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
46872
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46873
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46874
0
        ZVAL_NULL(EX_VAR(opline->result.var));
46875
0
      } else {
46876
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
46877
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
46878
0
      }
46879
0
    } else {
46880
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
46881
0
    }
46882
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46883
0
      zend_tmp_string_release(tmp_name);
46884
0
    }
46885
0
  } while (0);
46886
46887
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46888
46889
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46890
0
}
46891
46892
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46893
1.03k
{
46894
1.03k
  USE_OPLINE
46895
1.03k
  zval *container, *dim, *value;
46896
46897
1.03k
  SAVE_OPLINE();
46898
1.03k
  container = EX_VAR(opline->op1.var);
46899
1.03k
  dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46900
1.03k
  if (IS_CV != IS_CONST) {
46901
1.03k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46902
892
fetch_dim_r_array:
46903
892
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
46904
892
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46905
892
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
46906
0
      container = Z_REFVAL_P(container);
46907
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46908
0
        goto fetch_dim_r_array;
46909
0
      } else {
46910
0
        goto fetch_dim_r_slow;
46911
0
      }
46912
145
    } else {
46913
145
fetch_dim_r_slow:
46914
145
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46915
0
        dim++;
46916
0
      }
46917
145
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46918
145
    }
46919
1.03k
  } else {
46920
0
    zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
46921
0
  }
46922
1.03k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46923
46924
1.03k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46925
1.03k
}
46926
46927
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46928
196
{
46929
196
  USE_OPLINE
46930
196
  zval *container;
46931
46932
196
  SAVE_OPLINE();
46933
196
  container = EX_VAR(opline->op1.var);
46934
196
  zend_fetch_dimension_address_W(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
46935
196
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46936
196
  if (IS_CV == IS_VAR) {
46937
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46938
0
  }
46939
196
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46940
196
}
46941
46942
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46943
474
{
46944
474
  USE_OPLINE
46945
474
  zval *container;
46946
46947
474
  SAVE_OPLINE();
46948
474
  container = EX_VAR(opline->op1.var);
46949
474
  zend_fetch_dimension_address_RW(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
46950
474
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46951
474
  if (IS_CV == IS_VAR) {
46952
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46953
0
  }
46954
474
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46955
474
}
46956
46957
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46958
139
{
46959
139
  USE_OPLINE
46960
139
  zval *container;
46961
46962
139
  SAVE_OPLINE();
46963
139
  container = EX_VAR(opline->op1.var);
46964
139
  zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
46965
139
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46966
46967
139
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46968
139
}
46969
46970
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46971
0
{
46972
#if 0
46973
  USE_OPLINE
46974
#endif
46975
46976
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
46977
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
46978
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46979
0
    }
46980
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46981
0
  } else {
46982
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46983
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46984
0
    }
46985
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46986
0
  }
46987
0
}
46988
46989
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46990
0
{
46991
0
  USE_OPLINE
46992
0
  zval *container;
46993
46994
0
  SAVE_OPLINE();
46995
0
  container = EX_VAR(opline->op1.var);
46996
0
  zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
46997
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46998
0
  if (IS_CV == IS_VAR) {
46999
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47000
0
  }
47001
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47002
0
}
47003
47004
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47005
81
{
47006
81
  USE_OPLINE
47007
81
  zval *container;
47008
81
  void **cache_slot = NULL;
47009
47010
81
  SAVE_OPLINE();
47011
81
  container = EX_VAR(opline->op1.var);
47012
47013
81
  if (IS_CV == IS_CONST ||
47014
81
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
47015
18
    do {
47016
18
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
47017
10
        container = Z_REFVAL_P(container);
47018
10
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
47019
0
          break;
47020
0
        }
47021
10
      }
47022
18
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
47023
8
        ZVAL_UNDEFINED_OP1();
47024
8
      }
47025
18
      zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47026
18
      ZVAL_NULL(EX_VAR(opline->result.var));
47027
18
      goto fetch_obj_r_finish;
47028
18
    } while (0);
47029
18
  }
47030
47031
  /* here we are sure we are dealing with an object */
47032
63
  do {
47033
63
    zend_object *zobj = Z_OBJ_P(container);
47034
63
    zend_string *name, *tmp_name;
47035
63
    zval *retval;
47036
47037
63
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47038
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
47039
47040
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
47041
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47042
47043
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47044
0
fetch_obj_r_simple:
47045
0
          retval = OBJ_PROP(zobj, prop_offset);
47046
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
47047
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47048
0
              goto fetch_obj_r_copy;
47049
0
            } else {
47050
0
fetch_obj_r_fast_copy:
47051
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47052
0
              ZEND_VM_NEXT_OPCODE();
47053
0
            }
47054
0
          }
47055
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
47056
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47057
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
47058
0
            prop_offset = prop_info->offset;
47059
0
            goto fetch_obj_r_simple;
47060
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
47061
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
47062
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
47063
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
47064
47065
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
47066
0
            if (IS_CV & IS_CV) {
47067
0
              GC_ADDREF(zobj);
47068
0
            }
47069
0
            if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
47070
0
              call_info |= ZEND_CALL_RELEASE_THIS;
47071
0
            }
47072
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
47073
0
            call->prev_execute_data = execute_data;
47074
0
            call->call = NULL;
47075
0
            call->return_value = EX_VAR(opline->result.var);
47076
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
47077
47078
0
            execute_data = call;
47079
0
            EG(current_execute_data) = execute_data;
47080
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
47081
47082
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
47083
            opline = hook->op_array.opcodes;
47084
#else
47085
0
            EX(opline) = hook->op_array.opcodes;
47086
0
#endif
47087
0
            LOAD_OPLINE_EX();
47088
47089
47090
0
            ZEND_VM_ENTER_EX();
47091
0
          }
47092
          /* Fall through to read_property for hooks. */
47093
0
        } else if (EXPECTED(zobj->properties != NULL)) {
47094
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
47095
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47096
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
47097
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
47098
47099
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
47100
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
47101
47102
0
              if (EXPECTED(p->key == name) ||
47103
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
47104
0
                   EXPECTED(p->key != NULL) &&
47105
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
47106
0
                retval = &p->val;
47107
0
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47108
0
                  goto fetch_obj_r_copy;
47109
0
                } else {
47110
0
                  goto fetch_obj_r_fast_copy;
47111
0
                }
47112
0
              }
47113
0
            }
47114
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
47115
0
          }
47116
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
47117
0
          if (EXPECTED(retval)) {
47118
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
47119
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
47120
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47121
0
              goto fetch_obj_r_copy;
47122
0
            } else {
47123
0
              goto fetch_obj_r_fast_copy;
47124
0
            }
47125
0
          }
47126
0
        }
47127
0
      }
47128
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47129
63
    } else {
47130
63
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47131
63
      if (UNEXPECTED(!name)) {
47132
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
47133
5
        break;
47134
5
      }
47135
63
    }
47136
47137
58
#if ZEND_DEBUG
47138
    /* For non-standard object handlers, verify a declared property type in debug builds.
47139
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
47140
58
    zend_property_info *prop_info = NULL;
47141
58
    if (zobj->handlers->read_property != zend_std_read_property) {
47142
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
47143
0
    }
47144
58
#endif
47145
58
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
47146
58
#if ZEND_DEBUG
47147
58
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
47148
58
        && ZEND_TYPE_IS_SET(prop_info->type)) {
47149
0
      ZVAL_OPT_DEREF(retval);
47150
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
47151
0
    }
47152
58
#endif
47153
47154
58
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47155
58
      zend_tmp_string_release(tmp_name);
47156
58
    }
47157
47158
58
    if (retval != EX_VAR(opline->result.var)) {
47159
2
fetch_obj_r_copy:
47160
2
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47161
56
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
47162
0
      zend_unwrap_reference(retval);
47163
0
    }
47164
58
  } while (0);
47165
47166
81
fetch_obj_r_finish:
47167
81
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47168
47169
81
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47170
81
}
47171
47172
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47173
3
{
47174
3
  USE_OPLINE
47175
3
  zval *property, *container, *result;
47176
47177
3
  SAVE_OPLINE();
47178
47179
3
  container = EX_VAR(opline->op1.var);
47180
3
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47181
3
  result = EX_VAR(opline->result.var);
47182
3
  zend_fetch_property_address(
47183
3
    result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR),
47184
3
    (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
47185
3
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
47186
3
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47187
3
  if (IS_CV == IS_VAR) {
47188
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47189
0
  }
47190
3
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47191
3
}
47192
47193
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47194
0
{
47195
0
  USE_OPLINE
47196
0
  zval *property, *container, *result;
47197
47198
0
  SAVE_OPLINE();
47199
0
  container = EX_VAR(opline->op1.var);
47200
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47201
0
  result = EX_VAR(opline->result.var);
47202
0
  zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
47203
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47204
0
  if (IS_CV == IS_VAR) {
47205
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47206
0
  }
47207
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47208
0
}
47209
47210
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47211
35
{
47212
35
  USE_OPLINE
47213
35
  zval *container;
47214
35
  void **cache_slot = NULL;
47215
47216
35
  SAVE_OPLINE();
47217
35
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
47218
47219
35
  if (IS_CV == IS_CONST ||
47220
35
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
47221
0
    do {
47222
0
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
47223
0
        container = Z_REFVAL_P(container);
47224
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
47225
0
          break;
47226
0
        }
47227
0
      }
47228
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
47229
0
        ZVAL_UNDEFINED_OP2();
47230
0
      }
47231
0
      ZVAL_NULL(EX_VAR(opline->result.var));
47232
0
      goto fetch_obj_is_finish;
47233
0
    } while (0);
47234
0
  }
47235
47236
  /* here we are sure we are dealing with an object */
47237
35
  do {
47238
35
    zend_object *zobj = Z_OBJ_P(container);
47239
35
    zend_string *name, *tmp_name;
47240
35
    zval *retval;
47241
47242
35
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47243
0
      cache_slot = CACHE_ADDR(opline->extended_value);
47244
47245
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
47246
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47247
47248
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47249
0
fetch_obj_is_simple:
47250
0
          retval = OBJ_PROP(zobj, prop_offset);
47251
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
47252
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47253
0
              goto fetch_obj_is_copy;
47254
0
            } else {
47255
0
fetch_obj_is_fast_copy:
47256
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47257
0
              ZEND_VM_NEXT_OPCODE();
47258
0
            }
47259
0
          }
47260
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
47261
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
47262
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47263
0
            prop_offset = prop_info->offset;
47264
0
            goto fetch_obj_is_simple;
47265
0
          }
47266
          /* Fall through to read_property for hooks. */
47267
0
        } else if (EXPECTED(zobj->properties != NULL)) {
47268
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
47269
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47270
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
47271
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
47272
47273
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
47274
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
47275
47276
0
              if (EXPECTED(p->key == name) ||
47277
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
47278
0
                   EXPECTED(p->key != NULL) &&
47279
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
47280
0
                retval = &p->val;
47281
0
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47282
0
                  goto fetch_obj_is_copy;
47283
0
                } else {
47284
0
                  goto fetch_obj_is_fast_copy;
47285
0
                }
47286
0
              }
47287
0
            }
47288
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
47289
0
          }
47290
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
47291
0
          if (EXPECTED(retval)) {
47292
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
47293
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
47294
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47295
0
              goto fetch_obj_is_copy;
47296
0
            } else {
47297
0
              goto fetch_obj_is_fast_copy;
47298
0
            }
47299
0
          }
47300
0
        }
47301
0
      }
47302
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47303
35
    } else {
47304
35
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47305
35
      if (UNEXPECTED(!name)) {
47306
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
47307
0
        break;
47308
0
      }
47309
35
    }
47310
47311
35
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
47312
47313
35
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47314
35
      zend_tmp_string_release(tmp_name);
47315
35
    }
47316
47317
35
    if (retval != EX_VAR(opline->result.var)) {
47318
35
fetch_obj_is_copy:
47319
35
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47320
35
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
47321
0
      zend_unwrap_reference(retval);
47322
0
    }
47323
35
  } while (0);
47324
47325
35
fetch_obj_is_finish:
47326
35
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47327
47328
35
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47329
35
}
47330
47331
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47332
0
{
47333
#if 0
47334
  USE_OPLINE
47335
#endif
47336
47337
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
47338
    /* Behave like FETCH_OBJ_W */
47339
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
47340
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47341
0
    }
47342
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47343
0
  } else {
47344
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47345
0
  }
47346
0
}
47347
47348
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47349
0
{
47350
0
  USE_OPLINE
47351
0
  zval *container, *property, *result;
47352
47353
0
  SAVE_OPLINE();
47354
0
  container = EX_VAR(opline->op1.var);
47355
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47356
0
  result = EX_VAR(opline->result.var);
47357
0
  zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
47358
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47359
0
  if (IS_CV == IS_VAR) {
47360
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47361
0
  }
47362
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47363
0
}
47364
47365
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47366
71
{
47367
71
  USE_OPLINE
47368
71
  zval *object, *value, tmp;
47369
71
  zend_object *zobj;
47370
71
  zend_string *name, *tmp_name;
47371
71
  zend_refcounted *garbage = NULL;
47372
47373
71
  SAVE_OPLINE();
47374
71
  object = EX_VAR(opline->op1.var);
47375
71
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
47376
47377
71
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47378
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47379
0
      object = Z_REFVAL_P(object);
47380
0
      goto assign_object;
47381
0
    }
47382
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47383
0
    value = &EG(uninitialized_zval);
47384
0
    goto free_and_exit_assign_obj;
47385
0
  }
47386
47387
71
assign_object:
47388
71
  zobj = Z_OBJ_P(object);
47389
71
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47390
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47391
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
47392
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47393
0
      zval *property_val;
47394
0
      zend_property_info *prop_info;
47395
47396
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47397
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47398
47399
0
assign_obj_simple:
47400
0
        property_val = OBJ_PROP(zobj, prop_offset);
47401
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
47402
0
          if (prop_info != NULL) {
47403
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47404
0
            goto free_and_exit_assign_obj;
47405
0
          } else {
47406
0
fast_assign_obj:
47407
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
47408
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47409
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
47410
0
            }
47411
0
            goto exit_assign_obj;
47412
0
          }
47413
0
        }
47414
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47415
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47416
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47417
0
          zobj = zend_lazy_object_init(zobj);
47418
0
          if (!zobj) {
47419
0
            value = &EG(uninitialized_zval);
47420
0
            goto free_and_exit_assign_obj;
47421
0
          }
47422
0
        }
47423
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47424
0
          rebuild_object_properties_internal(zobj);
47425
0
        }
47426
0
        if (EXPECTED(zobj->properties != NULL)) {
47427
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47428
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47429
0
              GC_DELREF(zobj->properties);
47430
0
            }
47431
0
            zobj->properties = zend_array_dup(zobj->properties);
47432
0
          }
47433
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
47434
0
          if (property_val) {
47435
0
            goto fast_assign_obj;
47436
0
          }
47437
0
        }
47438
47439
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47440
0
          if (IS_CONST == IS_CONST) {
47441
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47442
0
              Z_ADDREF_P(value);
47443
0
            }
47444
0
          } else if (IS_CONST != IS_TMP_VAR) {
47445
0
            if (Z_ISREF_P(value)) {
47446
0
              if (IS_CONST == IS_VAR) {
47447
0
                zend_reference *ref = Z_REF_P(value);
47448
0
                if (GC_DELREF(ref) == 0) {
47449
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47450
0
                  efree_size(ref, sizeof(zend_reference));
47451
0
                  value = &tmp;
47452
0
                } else {
47453
0
                  value = Z_REFVAL_P(value);
47454
0
                  Z_TRY_ADDREF_P(value);
47455
0
                }
47456
0
              } else {
47457
0
                value = Z_REFVAL_P(value);
47458
0
                Z_TRY_ADDREF_P(value);
47459
0
              }
47460
0
            } else if (IS_CONST == IS_CV) {
47461
0
              Z_TRY_ADDREF_P(value);
47462
0
            }
47463
0
          }
47464
0
          zend_hash_add_new(zobj->properties, name, value);
47465
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47466
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
47467
0
          }
47468
0
          goto exit_assign_obj;
47469
0
        }
47470
0
      } else {
47471
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47472
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47473
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
47474
0
          prop_offset = prop_info->offset;
47475
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47476
0
            prop_info = NULL;
47477
0
          }
47478
0
          goto assign_obj_simple;
47479
0
        }
47480
        /* Fall through to write_property for hooks. */
47481
0
      }
47482
0
    }
47483
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47484
71
  } else {
47485
71
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47486
71
    if (UNEXPECTED(!name)) {
47487
47488
0
      UNDEF_RESULT();
47489
0
      goto exit_assign_obj;
47490
0
    }
47491
71
  }
47492
47493
71
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
47494
0
    ZVAL_DEREF(value);
47495
0
  }
47496
47497
71
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47498
47499
71
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47500
71
    zend_tmp_string_release(tmp_name);
47501
71
  }
47502
47503
71
free_and_exit_assign_obj:
47504
71
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47505
13
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47506
13
  }
47507
47508
71
exit_assign_obj:
47509
71
  if (garbage) {
47510
0
    GC_DTOR_NO_REF(garbage);
47511
0
  }
47512
71
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47513
47514
  /* assign_obj has two opcodes! */
47515
71
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
47516
71
}
47517
47518
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47519
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47520
0
{
47521
0
  USE_OPLINE
47522
0
  zval *object, *value, tmp;
47523
0
  zend_object *zobj;
47524
0
  zend_string *name, *tmp_name;
47525
0
  zend_refcounted *garbage = NULL;
47526
47527
0
  SAVE_OPLINE();
47528
0
  object = EX_VAR(opline->op1.var);
47529
0
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
47530
47531
0
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47532
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47533
0
      object = Z_REFVAL_P(object);
47534
0
      goto assign_object;
47535
0
    }
47536
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47537
0
    value = &EG(uninitialized_zval);
47538
0
    goto free_and_exit_assign_obj;
47539
0
  }
47540
47541
0
assign_object:
47542
0
  zobj = Z_OBJ_P(object);
47543
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47544
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47545
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
47546
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47547
0
      zval *property_val;
47548
0
      zend_property_info *prop_info;
47549
47550
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47551
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47552
47553
0
assign_obj_simple:
47554
0
        property_val = OBJ_PROP(zobj, prop_offset);
47555
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
47556
0
          if (prop_info != NULL) {
47557
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47558
0
            goto free_and_exit_assign_obj;
47559
0
          } else {
47560
0
fast_assign_obj:
47561
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
47562
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47563
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
47564
0
            }
47565
0
            goto exit_assign_obj;
47566
0
          }
47567
0
        }
47568
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47569
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47570
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47571
0
          zobj = zend_lazy_object_init(zobj);
47572
0
          if (!zobj) {
47573
0
            value = &EG(uninitialized_zval);
47574
0
            goto free_and_exit_assign_obj;
47575
0
          }
47576
0
        }
47577
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47578
0
          rebuild_object_properties_internal(zobj);
47579
0
        }
47580
0
        if (EXPECTED(zobj->properties != NULL)) {
47581
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47582
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47583
0
              GC_DELREF(zobj->properties);
47584
0
            }
47585
0
            zobj->properties = zend_array_dup(zobj->properties);
47586
0
          }
47587
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
47588
0
          if (property_val) {
47589
0
            goto fast_assign_obj;
47590
0
          }
47591
0
        }
47592
47593
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47594
0
          if (IS_TMP_VAR == IS_CONST) {
47595
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47596
0
              Z_ADDREF_P(value);
47597
0
            }
47598
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
47599
0
            if (Z_ISREF_P(value)) {
47600
0
              if (IS_TMP_VAR == IS_VAR) {
47601
0
                zend_reference *ref = Z_REF_P(value);
47602
0
                if (GC_DELREF(ref) == 0) {
47603
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47604
0
                  efree_size(ref, sizeof(zend_reference));
47605
0
                  value = &tmp;
47606
0
                } else {
47607
0
                  value = Z_REFVAL_P(value);
47608
0
                  Z_TRY_ADDREF_P(value);
47609
0
                }
47610
0
              } else {
47611
0
                value = Z_REFVAL_P(value);
47612
0
                Z_TRY_ADDREF_P(value);
47613
0
              }
47614
0
            } else if (IS_TMP_VAR == IS_CV) {
47615
0
              Z_TRY_ADDREF_P(value);
47616
0
            }
47617
0
          }
47618
0
          zend_hash_add_new(zobj->properties, name, value);
47619
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47620
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
47621
0
          }
47622
0
          goto exit_assign_obj;
47623
0
        }
47624
0
      } else {
47625
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47626
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47627
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
47628
0
          prop_offset = prop_info->offset;
47629
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47630
0
            prop_info = NULL;
47631
0
          }
47632
0
          goto assign_obj_simple;
47633
0
        }
47634
        /* Fall through to write_property for hooks. */
47635
0
      }
47636
0
    }
47637
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47638
0
  } else {
47639
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47640
0
    if (UNEXPECTED(!name)) {
47641
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47642
0
      UNDEF_RESULT();
47643
0
      goto exit_assign_obj;
47644
0
    }
47645
0
  }
47646
47647
0
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
47648
0
    ZVAL_DEREF(value);
47649
0
  }
47650
47651
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47652
47653
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47654
0
    zend_tmp_string_release(tmp_name);
47655
0
  }
47656
47657
0
free_and_exit_assign_obj:
47658
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47659
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47660
0
  }
47661
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47662
0
exit_assign_obj:
47663
0
  if (garbage) {
47664
0
    GC_DTOR_NO_REF(garbage);
47665
0
  }
47666
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47667
47668
  /* assign_obj has two opcodes! */
47669
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
47670
0
}
47671
47672
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47673
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47674
0
{
47675
0
  USE_OPLINE
47676
0
  zval *object, *value, tmp;
47677
0
  zend_object *zobj;
47678
0
  zend_string *name, *tmp_name;
47679
0
  zend_refcounted *garbage = NULL;
47680
47681
0
  SAVE_OPLINE();
47682
0
  object = EX_VAR(opline->op1.var);
47683
0
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
47684
47685
0
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47686
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47687
0
      object = Z_REFVAL_P(object);
47688
0
      goto assign_object;
47689
0
    }
47690
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47691
0
    value = &EG(uninitialized_zval);
47692
0
    goto free_and_exit_assign_obj;
47693
0
  }
47694
47695
0
assign_object:
47696
0
  zobj = Z_OBJ_P(object);
47697
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47698
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47699
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
47700
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47701
0
      zval *property_val;
47702
0
      zend_property_info *prop_info;
47703
47704
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47705
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47706
47707
0
assign_obj_simple:
47708
0
        property_val = OBJ_PROP(zobj, prop_offset);
47709
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
47710
0
          if (prop_info != NULL) {
47711
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47712
0
            goto free_and_exit_assign_obj;
47713
0
          } else {
47714
0
fast_assign_obj:
47715
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
47716
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47717
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
47718
0
            }
47719
0
            goto exit_assign_obj;
47720
0
          }
47721
0
        }
47722
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47723
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47724
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47725
0
          zobj = zend_lazy_object_init(zobj);
47726
0
          if (!zobj) {
47727
0
            value = &EG(uninitialized_zval);
47728
0
            goto free_and_exit_assign_obj;
47729
0
          }
47730
0
        }
47731
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47732
0
          rebuild_object_properties_internal(zobj);
47733
0
        }
47734
0
        if (EXPECTED(zobj->properties != NULL)) {
47735
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47736
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47737
0
              GC_DELREF(zobj->properties);
47738
0
            }
47739
0
            zobj->properties = zend_array_dup(zobj->properties);
47740
0
          }
47741
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
47742
0
          if (property_val) {
47743
0
            goto fast_assign_obj;
47744
0
          }
47745
0
        }
47746
47747
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47748
0
          if (IS_VAR == IS_CONST) {
47749
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47750
0
              Z_ADDREF_P(value);
47751
0
            }
47752
0
          } else if (IS_VAR != IS_TMP_VAR) {
47753
0
            if (Z_ISREF_P(value)) {
47754
0
              if (IS_VAR == IS_VAR) {
47755
0
                zend_reference *ref = Z_REF_P(value);
47756
0
                if (GC_DELREF(ref) == 0) {
47757
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47758
0
                  efree_size(ref, sizeof(zend_reference));
47759
0
                  value = &tmp;
47760
0
                } else {
47761
0
                  value = Z_REFVAL_P(value);
47762
0
                  Z_TRY_ADDREF_P(value);
47763
0
                }
47764
0
              } else {
47765
0
                value = Z_REFVAL_P(value);
47766
0
                Z_TRY_ADDREF_P(value);
47767
0
              }
47768
0
            } else if (IS_VAR == IS_CV) {
47769
0
              Z_TRY_ADDREF_P(value);
47770
0
            }
47771
0
          }
47772
0
          zend_hash_add_new(zobj->properties, name, value);
47773
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47774
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
47775
0
          }
47776
0
          goto exit_assign_obj;
47777
0
        }
47778
0
      } else {
47779
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47780
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47781
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
47782
0
          prop_offset = prop_info->offset;
47783
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47784
0
            prop_info = NULL;
47785
0
          }
47786
0
          goto assign_obj_simple;
47787
0
        }
47788
        /* Fall through to write_property for hooks. */
47789
0
      }
47790
0
    }
47791
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47792
0
  } else {
47793
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47794
0
    if (UNEXPECTED(!name)) {
47795
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47796
0
      UNDEF_RESULT();
47797
0
      goto exit_assign_obj;
47798
0
    }
47799
0
  }
47800
47801
0
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
47802
0
    ZVAL_DEREF(value);
47803
0
  }
47804
47805
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47806
47807
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47808
0
    zend_tmp_string_release(tmp_name);
47809
0
  }
47810
47811
0
free_and_exit_assign_obj:
47812
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47813
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47814
0
  }
47815
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47816
0
exit_assign_obj:
47817
0
  if (garbage) {
47818
0
    GC_DTOR_NO_REF(garbage);
47819
0
  }
47820
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47821
47822
  /* assign_obj has two opcodes! */
47823
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
47824
0
}
47825
47826
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47827
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47828
409
{
47829
409
  USE_OPLINE
47830
409
  zval *object, *value, tmp;
47831
409
  zend_object *zobj;
47832
409
  zend_string *name, *tmp_name;
47833
409
  zend_refcounted *garbage = NULL;
47834
47835
409
  SAVE_OPLINE();
47836
409
  object = EX_VAR(opline->op1.var);
47837
409
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
47838
47839
409
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47840
398
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47841
398
      object = Z_REFVAL_P(object);
47842
398
      goto assign_object;
47843
398
    }
47844
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47845
0
    value = &EG(uninitialized_zval);
47846
0
    goto free_and_exit_assign_obj;
47847
398
  }
47848
47849
409
assign_object:
47850
409
  zobj = Z_OBJ_P(object);
47851
409
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47852
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47853
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
47854
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47855
0
      zval *property_val;
47856
0
      zend_property_info *prop_info;
47857
47858
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47859
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47860
47861
0
assign_obj_simple:
47862
0
        property_val = OBJ_PROP(zobj, prop_offset);
47863
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
47864
0
          if (prop_info != NULL) {
47865
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47866
0
            goto free_and_exit_assign_obj;
47867
0
          } else {
47868
0
fast_assign_obj:
47869
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
47870
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47871
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
47872
0
            }
47873
0
            goto exit_assign_obj;
47874
0
          }
47875
0
        }
47876
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47877
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47878
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47879
0
          zobj = zend_lazy_object_init(zobj);
47880
0
          if (!zobj) {
47881
0
            value = &EG(uninitialized_zval);
47882
0
            goto free_and_exit_assign_obj;
47883
0
          }
47884
0
        }
47885
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47886
0
          rebuild_object_properties_internal(zobj);
47887
0
        }
47888
0
        if (EXPECTED(zobj->properties != NULL)) {
47889
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47890
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47891
0
              GC_DELREF(zobj->properties);
47892
0
            }
47893
0
            zobj->properties = zend_array_dup(zobj->properties);
47894
0
          }
47895
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
47896
0
          if (property_val) {
47897
0
            goto fast_assign_obj;
47898
0
          }
47899
0
        }
47900
47901
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47902
0
          if (IS_CV == IS_CONST) {
47903
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47904
0
              Z_ADDREF_P(value);
47905
0
            }
47906
0
          } else if (IS_CV != IS_TMP_VAR) {
47907
0
            if (Z_ISREF_P(value)) {
47908
0
              if (IS_CV == IS_VAR) {
47909
0
                zend_reference *ref = Z_REF_P(value);
47910
0
                if (GC_DELREF(ref) == 0) {
47911
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47912
0
                  efree_size(ref, sizeof(zend_reference));
47913
0
                  value = &tmp;
47914
0
                } else {
47915
0
                  value = Z_REFVAL_P(value);
47916
0
                  Z_TRY_ADDREF_P(value);
47917
0
                }
47918
0
              } else {
47919
0
                value = Z_REFVAL_P(value);
47920
0
                Z_TRY_ADDREF_P(value);
47921
0
              }
47922
0
            } else if (IS_CV == IS_CV) {
47923
0
              Z_TRY_ADDREF_P(value);
47924
0
            }
47925
0
          }
47926
0
          zend_hash_add_new(zobj->properties, name, value);
47927
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47928
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
47929
0
          }
47930
0
          goto exit_assign_obj;
47931
0
        }
47932
0
      } else {
47933
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47934
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47935
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
47936
0
          prop_offset = prop_info->offset;
47937
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47938
0
            prop_info = NULL;
47939
0
          }
47940
0
          goto assign_obj_simple;
47941
0
        }
47942
        /* Fall through to write_property for hooks. */
47943
0
      }
47944
0
    }
47945
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47946
409
  } else {
47947
409
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47948
409
    if (UNEXPECTED(!name)) {
47949
47950
0
      UNDEF_RESULT();
47951
0
      goto exit_assign_obj;
47952
0
    }
47953
409
  }
47954
47955
409
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
47956
409
    ZVAL_DEREF(value);
47957
409
  }
47958
47959
409
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47960
47961
409
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47962
409
    zend_tmp_string_release(tmp_name);
47963
409
  }
47964
47965
409
free_and_exit_assign_obj:
47966
409
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47967
11
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47968
11
  }
47969
47970
409
exit_assign_obj:
47971
409
  if (garbage) {
47972
0
    GC_DTOR_NO_REF(garbage);
47973
0
  }
47974
409
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47975
47976
  /* assign_obj has two opcodes! */
47977
409
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
47978
409
}
47979
47980
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47981
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47982
293
{
47983
293
  USE_OPLINE
47984
293
  zval *object_ptr, *orig_object_ptr;
47985
293
  zval *value;
47986
293
  zval *variable_ptr;
47987
293
  zval *dim;
47988
293
  zend_refcounted *garbage = NULL;
47989
47990
293
  SAVE_OPLINE();
47991
293
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
47992
47993
293
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47994
176
try_assign_dim_array:
47995
176
    SEPARATE_ARRAY(object_ptr);
47996
176
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
47997
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
47998
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
47999
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
48000
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48001
0
          GC_ADDREF(ht);
48002
0
        }
48003
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48004
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48005
0
          zend_array_destroy(ht);
48006
0
          goto assign_dim_error;
48007
0
        }
48008
0
      }
48009
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
48010
0
        ZVAL_DEREF(value);
48011
0
      }
48012
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48013
0
      if (UNEXPECTED(value == NULL)) {
48014
0
        zend_cannot_add_element();
48015
0
        goto assign_dim_error;
48016
0
      } else if (IS_CONST == IS_CV) {
48017
0
        if (Z_REFCOUNTED_P(value)) {
48018
0
          Z_ADDREF_P(value);
48019
0
        }
48020
0
      } else if (IS_CONST == IS_VAR) {
48021
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
48022
0
        if (Z_ISREF_P(free_op_data)) {
48023
0
          if (Z_REFCOUNTED_P(value)) {
48024
0
            Z_ADDREF_P(value);
48025
0
          }
48026
0
          zval_ptr_dtor_nogc(free_op_data);
48027
0
        }
48028
0
      } else if (IS_CONST == IS_CONST) {
48029
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48030
0
          Z_ADDREF_P(value);
48031
0
        }
48032
0
      }
48033
176
    } else {
48034
176
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48035
176
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48036
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48037
176
      } else {
48038
176
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48039
176
      }
48040
176
      if (UNEXPECTED(variable_ptr == NULL)) {
48041
26
        goto assign_dim_error;
48042
26
      }
48043
150
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
48044
150
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
48045
150
    }
48046
150
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48047
26
      ZVAL_COPY(EX_VAR(opline->result.var), value);
48048
26
    }
48049
150
    if (garbage) {
48050
124
      GC_DTOR_NO_REF(garbage);
48051
124
    }
48052
251
  } else {
48053
251
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
48054
124
      object_ptr = Z_REFVAL_P(object_ptr);
48055
124
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48056
124
        goto try_assign_dim_array;
48057
124
      }
48058
124
    }
48059
127
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48060
104
      zend_object *obj = Z_OBJ_P(object_ptr);
48061
48062
104
      GC_ADDREF(obj);
48063
104
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48064
104
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48065
0
        dim = ZVAL_UNDEFINED_OP2();
48066
104
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48067
0
        dim++;
48068
0
      }
48069
48070
104
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
48071
104
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48072
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48073
104
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
48074
0
        ZVAL_DEREF(value);
48075
0
      }
48076
48077
104
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48078
48079
104
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48080
0
        zend_objects_store_del(obj);
48081
0
      }
48082
104
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48083
13
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48084
0
        zend_use_new_element_for_string();
48085
48086
0
        UNDEF_RESULT();
48087
13
      } else {
48088
13
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48089
13
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
48090
13
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48091
48092
13
      }
48093
13
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48094
10
      if (Z_ISREF_P(orig_object_ptr)
48095
10
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48096
10
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48097
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48098
48099
0
        UNDEF_RESULT();
48100
10
      } else {
48101
10
        HashTable *ht = zend_new_array(8);
48102
10
        uint8_t old_type = Z_TYPE_P(object_ptr);
48103
48104
10
        ZVAL_ARR(object_ptr, ht);
48105
10
        if (UNEXPECTED(old_type == IS_FALSE)) {
48106
0
          GC_ADDREF(ht);
48107
0
          zend_false_to_array_deprecated();
48108
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48109
0
            zend_array_destroy(ht);
48110
0
            goto assign_dim_error;
48111
0
          }
48112
0
        }
48113
10
        goto try_assign_dim_array;
48114
10
      }
48115
10
    } else {
48116
0
      zend_use_scalar_as_array();
48117
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48118
26
assign_dim_error:
48119
48120
26
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48121
8
        ZVAL_NULL(EX_VAR(opline->result.var));
48122
8
      }
48123
26
    }
48124
127
  }
48125
293
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48126
293
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48127
293
  }
48128
48129
  /* assign_dim has two opcodes! */
48130
293
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48131
293
}
48132
48133
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48134
268
{
48135
268
  USE_OPLINE
48136
268
  zval *object_ptr, *orig_object_ptr;
48137
268
  zval *value;
48138
268
  zval *variable_ptr;
48139
268
  zval *dim;
48140
268
  zend_refcounted *garbage = NULL;
48141
48142
268
  SAVE_OPLINE();
48143
268
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48144
48145
268
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48146
230
try_assign_dim_array:
48147
230
    SEPARATE_ARRAY(object_ptr);
48148
230
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48149
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48150
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48151
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
48152
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48153
0
          GC_ADDREF(ht);
48154
0
        }
48155
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48156
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48157
0
          zend_array_destroy(ht);
48158
0
          goto assign_dim_error;
48159
0
        }
48160
0
      }
48161
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
48162
0
        ZVAL_DEREF(value);
48163
0
      }
48164
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48165
0
      if (UNEXPECTED(value == NULL)) {
48166
0
        zend_cannot_add_element();
48167
0
        goto assign_dim_error;
48168
0
      } else if (IS_TMP_VAR == IS_CV) {
48169
0
        if (Z_REFCOUNTED_P(value)) {
48170
0
          Z_ADDREF_P(value);
48171
0
        }
48172
0
      } else if (IS_TMP_VAR == IS_VAR) {
48173
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
48174
0
        if (Z_ISREF_P(free_op_data)) {
48175
0
          if (Z_REFCOUNTED_P(value)) {
48176
0
            Z_ADDREF_P(value);
48177
0
          }
48178
0
          zval_ptr_dtor_nogc(free_op_data);
48179
0
        }
48180
0
      } else if (IS_TMP_VAR == IS_CONST) {
48181
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48182
0
          Z_ADDREF_P(value);
48183
0
        }
48184
0
      }
48185
230
    } else {
48186
230
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48187
230
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48188
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48189
230
      } else {
48190
230
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48191
230
      }
48192
230
      if (UNEXPECTED(variable_ptr == NULL)) {
48193
0
        goto assign_dim_error;
48194
0
      }
48195
230
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48196
230
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48197
230
    }
48198
230
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48199
13
      ZVAL_COPY(EX_VAR(opline->result.var), value);
48200
13
    }
48201
230
    if (garbage) {
48202
0
      GC_DTOR_NO_REF(garbage);
48203
0
    }
48204
230
  } else {
48205
176
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
48206
124
      object_ptr = Z_REFVAL_P(object_ptr);
48207
124
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48208
124
        goto try_assign_dim_array;
48209
124
      }
48210
124
    }
48211
52
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48212
0
      zend_object *obj = Z_OBJ_P(object_ptr);
48213
48214
0
      GC_ADDREF(obj);
48215
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48216
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48217
0
        dim = ZVAL_UNDEFINED_OP2();
48218
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48219
0
        dim++;
48220
0
      }
48221
48222
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48223
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48224
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48225
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
48226
0
        ZVAL_DEREF(value);
48227
0
      }
48228
48229
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48230
48231
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48232
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48233
0
        zend_objects_store_del(obj);
48234
0
      }
48235
52
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48236
38
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48237
0
        zend_use_new_element_for_string();
48238
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48239
0
        UNDEF_RESULT();
48240
38
      } else {
48241
38
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48242
38
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48243
38
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48244
38
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48245
38
      }
48246
38
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48247
14
      if (Z_ISREF_P(orig_object_ptr)
48248
14
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48249
14
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48250
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48251
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48252
0
        UNDEF_RESULT();
48253
14
      } else {
48254
14
        HashTable *ht = zend_new_array(8);
48255
14
        uint8_t old_type = Z_TYPE_P(object_ptr);
48256
48257
14
        ZVAL_ARR(object_ptr, ht);
48258
14
        if (UNEXPECTED(old_type == IS_FALSE)) {
48259
0
          GC_ADDREF(ht);
48260
0
          zend_false_to_array_deprecated();
48261
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48262
0
            zend_array_destroy(ht);
48263
0
            goto assign_dim_error;
48264
0
          }
48265
0
        }
48266
14
        goto try_assign_dim_array;
48267
14
      }
48268
14
    } else {
48269
0
      zend_use_scalar_as_array();
48270
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48271
0
assign_dim_error:
48272
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48273
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48274
0
        ZVAL_NULL(EX_VAR(opline->result.var));
48275
0
      }
48276
0
    }
48277
52
  }
48278
268
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48279
268
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48280
268
  }
48281
48282
  /* assign_dim has two opcodes! */
48283
268
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48284
268
}
48285
48286
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48287
584
{
48288
584
  USE_OPLINE
48289
584
  zval *object_ptr, *orig_object_ptr;
48290
584
  zval *value;
48291
584
  zval *variable_ptr;
48292
584
  zval *dim;
48293
584
  zend_refcounted *garbage = NULL;
48294
48295
584
  SAVE_OPLINE();
48296
584
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48297
48298
584
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48299
572
try_assign_dim_array:
48300
572
    SEPARATE_ARRAY(object_ptr);
48301
572
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48302
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48303
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48304
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
48305
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48306
0
          GC_ADDREF(ht);
48307
0
        }
48308
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48309
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48310
0
          zend_array_destroy(ht);
48311
0
          goto assign_dim_error;
48312
0
        }
48313
0
      }
48314
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
48315
0
        ZVAL_DEREF(value);
48316
0
      }
48317
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48318
0
      if (UNEXPECTED(value == NULL)) {
48319
0
        zend_cannot_add_element();
48320
0
        goto assign_dim_error;
48321
0
      } else if (IS_VAR == IS_CV) {
48322
0
        if (Z_REFCOUNTED_P(value)) {
48323
0
          Z_ADDREF_P(value);
48324
0
        }
48325
0
      } else if (IS_VAR == IS_VAR) {
48326
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
48327
0
        if (Z_ISREF_P(free_op_data)) {
48328
0
          if (Z_REFCOUNTED_P(value)) {
48329
0
            Z_ADDREF_P(value);
48330
0
          }
48331
0
          zval_ptr_dtor_nogc(free_op_data);
48332
0
        }
48333
0
      } else if (IS_VAR == IS_CONST) {
48334
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48335
0
          Z_ADDREF_P(value);
48336
0
        }
48337
0
      }
48338
572
    } else {
48339
572
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48340
572
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48341
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48342
572
      } else {
48343
572
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48344
572
      }
48345
572
      if (UNEXPECTED(variable_ptr == NULL)) {
48346
3
        goto assign_dim_error;
48347
3
      }
48348
569
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48349
569
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48350
569
    }
48351
569
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48352
48
      ZVAL_COPY(EX_VAR(opline->result.var), value);
48353
48
    }
48354
569
    if (garbage) {
48355
139
      GC_DTOR_NO_REF(garbage);
48356
139
    }
48357
569
  } else {
48358
431
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
48359
0
      object_ptr = Z_REFVAL_P(object_ptr);
48360
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48361
0
        goto try_assign_dim_array;
48362
0
      }
48363
0
    }
48364
431
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48365
7
      zend_object *obj = Z_OBJ_P(object_ptr);
48366
48367
7
      GC_ADDREF(obj);
48368
7
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48369
7
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48370
0
        dim = ZVAL_UNDEFINED_OP2();
48371
7
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48372
0
        dim++;
48373
0
      }
48374
48375
7
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48376
7
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48377
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48378
7
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
48379
7
        ZVAL_DEREF(value);
48380
7
      }
48381
48382
7
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48383
48384
7
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48385
7
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48386
0
        zend_objects_store_del(obj);
48387
0
      }
48388
424
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48389
5
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48390
0
        zend_use_new_element_for_string();
48391
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48392
0
        UNDEF_RESULT();
48393
5
      } else {
48394
5
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48395
5
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48396
5
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48397
5
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48398
5
      }
48399
419
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48400
419
      if (Z_ISREF_P(orig_object_ptr)
48401
419
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48402
419
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48403
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48404
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48405
0
        UNDEF_RESULT();
48406
419
      } else {
48407
419
        HashTable *ht = zend_new_array(8);
48408
419
        uint8_t old_type = Z_TYPE_P(object_ptr);
48409
48410
419
        ZVAL_ARR(object_ptr, ht);
48411
419
        if (UNEXPECTED(old_type == IS_FALSE)) {
48412
0
          GC_ADDREF(ht);
48413
0
          zend_false_to_array_deprecated();
48414
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48415
0
            zend_array_destroy(ht);
48416
0
            goto assign_dim_error;
48417
0
          }
48418
0
        }
48419
419
        goto try_assign_dim_array;
48420
419
      }
48421
419
    } else {
48422
0
      zend_use_scalar_as_array();
48423
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48424
3
assign_dim_error:
48425
3
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48426
3
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48427
0
        ZVAL_NULL(EX_VAR(opline->result.var));
48428
0
      }
48429
3
    }
48430
431
  }
48431
584
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48432
584
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48433
584
  }
48434
48435
  /* assign_dim has two opcodes! */
48436
584
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48437
584
}
48438
48439
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48440
537
{
48441
537
  USE_OPLINE
48442
537
  zval *object_ptr, *orig_object_ptr;
48443
537
  zval *value;
48444
537
  zval *variable_ptr;
48445
537
  zval *dim;
48446
537
  zend_refcounted *garbage = NULL;
48447
48448
537
  SAVE_OPLINE();
48449
537
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48450
48451
537
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48452
537
try_assign_dim_array:
48453
537
    SEPARATE_ARRAY(object_ptr);
48454
537
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48455
0
      value = EX_VAR((opline+1)->op1.var);
48456
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48457
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
48458
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48459
0
          GC_ADDREF(ht);
48460
0
        }
48461
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48462
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48463
0
          zend_array_destroy(ht);
48464
0
          goto assign_dim_error;
48465
0
        }
48466
0
      }
48467
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
48468
0
        ZVAL_DEREF(value);
48469
0
      }
48470
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48471
0
      if (UNEXPECTED(value == NULL)) {
48472
0
        zend_cannot_add_element();
48473
0
        goto assign_dim_error;
48474
0
      } else if (IS_CV == IS_CV) {
48475
0
        if (Z_REFCOUNTED_P(value)) {
48476
0
          Z_ADDREF_P(value);
48477
0
        }
48478
0
      } else if (IS_CV == IS_VAR) {
48479
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
48480
0
        if (Z_ISREF_P(free_op_data)) {
48481
0
          if (Z_REFCOUNTED_P(value)) {
48482
0
            Z_ADDREF_P(value);
48483
0
          }
48484
0
          zval_ptr_dtor_nogc(free_op_data);
48485
0
        }
48486
0
      } else if (IS_CV == IS_CONST) {
48487
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48488
0
          Z_ADDREF_P(value);
48489
0
        }
48490
0
      }
48491
537
    } else {
48492
537
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48493
537
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48494
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48495
537
      } else {
48496
537
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48497
537
      }
48498
537
      if (UNEXPECTED(variable_ptr == NULL)) {
48499
0
        goto assign_dim_error;
48500
0
      }
48501
537
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
48502
537
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
48503
537
    }
48504
537
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48505
265
      ZVAL_COPY(EX_VAR(opline->result.var), value);
48506
265
    }
48507
537
    if (garbage) {
48508
0
      GC_DTOR_NO_REF(garbage);
48509
0
    }
48510
537
  } else {
48511
50
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
48512
0
      object_ptr = Z_REFVAL_P(object_ptr);
48513
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48514
0
        goto try_assign_dim_array;
48515
0
      }
48516
0
    }
48517
50
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48518
0
      zend_object *obj = Z_OBJ_P(object_ptr);
48519
48520
0
      GC_ADDREF(obj);
48521
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48522
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48523
0
        dim = ZVAL_UNDEFINED_OP2();
48524
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48525
0
        dim++;
48526
0
      }
48527
48528
0
      value = EX_VAR((opline+1)->op1.var);
48529
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48530
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48531
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
48532
0
        ZVAL_DEREF(value);
48533
0
      }
48534
48535
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48536
48537
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48538
0
        zend_objects_store_del(obj);
48539
0
      }
48540
50
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48541
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48542
0
        zend_use_new_element_for_string();
48543
48544
0
        UNDEF_RESULT();
48545
0
      } else {
48546
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48547
0
        value = EX_VAR((opline+1)->op1.var);
48548
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48549
48550
0
      }
48551
50
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48552
50
      if (Z_ISREF_P(orig_object_ptr)
48553
50
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48554
50
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48555
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48556
48557
0
        UNDEF_RESULT();
48558
50
      } else {
48559
50
        HashTable *ht = zend_new_array(8);
48560
50
        uint8_t old_type = Z_TYPE_P(object_ptr);
48561
48562
50
        ZVAL_ARR(object_ptr, ht);
48563
50
        if (UNEXPECTED(old_type == IS_FALSE)) {
48564
0
          GC_ADDREF(ht);
48565
0
          zend_false_to_array_deprecated();
48566
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48567
0
            zend_array_destroy(ht);
48568
0
            goto assign_dim_error;
48569
0
          }
48570
0
        }
48571
50
        goto try_assign_dim_array;
48572
50
      }
48573
50
    } else {
48574
0
      zend_use_scalar_as_array();
48575
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48576
0
assign_dim_error:
48577
48578
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48579
0
        ZVAL_NULL(EX_VAR(opline->result.var));
48580
0
      }
48581
0
    }
48582
50
  }
48583
537
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48584
537
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48585
537
  }
48586
48587
  /* assign_dim has two opcodes! */
48588
537
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48589
537
}
48590
48591
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48592
0
{
48593
0
  USE_OPLINE
48594
0
  zval *property, *container, *value_ptr;
48595
48596
0
  SAVE_OPLINE();
48597
48598
0
  container = EX_VAR(opline->op1.var);
48599
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48600
48601
0
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48602
48603
0
  if (1) {
48604
0
    if (IS_CV == IS_UNUSED) {
48605
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48606
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48607
0
      } else {
48608
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48609
0
      }
48610
0
    } else {
48611
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48612
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48613
0
      } else {
48614
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48615
0
      }
48616
0
    }
48617
0
  } else {
48618
0
    zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
48619
0
  }
48620
48621
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48622
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48623
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48624
0
}
48625
48626
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
48627
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48628
0
{
48629
0
  USE_OPLINE
48630
0
  zval *property, *container, *value_ptr;
48631
48632
0
  SAVE_OPLINE();
48633
48634
0
  container = EX_VAR(opline->op1.var);
48635
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48636
48637
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
48638
48639
0
  if (1) {
48640
0
    if (IS_CV == IS_UNUSED) {
48641
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48642
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48643
0
      } else {
48644
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48645
0
      }
48646
0
    } else {
48647
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48648
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48649
0
      } else {
48650
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48651
0
      }
48652
0
    }
48653
0
  } else {
48654
0
    zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
48655
0
  }
48656
48657
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48658
48659
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48660
0
}
48661
48662
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
48663
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48664
1.21k
{
48665
1.21k
  USE_OPLINE
48666
1.21k
  zval *op1, *op2;
48667
1.21k
  zend_string *op1_str, *op2_str, *str;
48668
48669
48670
1.21k
  op1 = EX_VAR(opline->op1.var);
48671
1.21k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48672
1.21k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
48673
1.21k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
48674
57
    zend_string *op1_str = Z_STR_P(op1);
48675
57
    zend_string *op2_str = Z_STR_P(op2);
48676
57
    zend_string *str;
48677
57
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
48678
48679
57
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
48680
2
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
48681
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
48682
2
      } else {
48683
2
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
48684
2
      }
48685
2
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
48686
0
        zend_string_release_ex(op1_str, 0);
48687
0
      }
48688
55
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
48689
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
48690
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
48691
0
      } else {
48692
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
48693
0
      }
48694
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48695
0
        zend_string_release_ex(op2_str, 0);
48696
0
      }
48697
55
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
48698
55
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
48699
0
      size_t len = ZSTR_LEN(op1_str);
48700
48701
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
48702
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48703
0
      GC_ADD_FLAGS(str, flags);
48704
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48705
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48706
0
        zend_string_release_ex(op2_str, 0);
48707
0
      }
48708
55
    } else {
48709
55
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
48710
55
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
48711
55
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48712
55
      GC_ADD_FLAGS(str, flags);
48713
55
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48714
55
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
48715
0
        zend_string_release_ex(op1_str, 0);
48716
0
      }
48717
55
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48718
53
        zend_string_release_ex(op2_str, 0);
48719
53
      }
48720
55
    }
48721
57
    ZEND_VM_NEXT_OPCODE();
48722
57
  }
48723
48724
1.21k
  SAVE_OPLINE();
48725
1.15k
  if (IS_CV == IS_CONST) {
48726
0
    op1_str = Z_STR_P(op1);
48727
1.15k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
48728
617
    op1_str = zend_string_copy(Z_STR_P(op1));
48729
617
  } else {
48730
539
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
48731
195
      ZVAL_UNDEFINED_OP1();
48732
195
    }
48733
539
    op1_str = zval_get_string_func(op1);
48734
539
  }
48735
1.15k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48736
0
    op2_str = Z_STR_P(op2);
48737
1.15k
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
48738
7
    op2_str = zend_string_copy(Z_STR_P(op2));
48739
1.14k
  } else {
48740
1.14k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
48741
0
      ZVAL_UNDEFINED_OP2();
48742
0
    }
48743
1.14k
    op2_str = zval_get_string_func(op2);
48744
1.14k
  }
48745
1.15k
  do {
48746
1.15k
    if (IS_CV != IS_CONST) {
48747
1.15k
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
48748
291
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48749
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
48750
0
            GC_ADDREF(op2_str);
48751
0
          }
48752
0
        }
48753
291
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
48754
291
        zend_string_release_ex(op1_str, 0);
48755
291
        break;
48756
291
      }
48757
1.15k
    }
48758
865
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48759
865
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
48760
99
        if (IS_CV == IS_CONST) {
48761
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
48762
0
            GC_ADDREF(op1_str);
48763
0
          }
48764
0
        }
48765
99
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
48766
99
        zend_string_release_ex(op2_str, 0);
48767
99
        break;
48768
99
      }
48769
865
    }
48770
766
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
48771
766
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
48772
766
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48773
48774
766
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
48775
766
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48776
766
    if (IS_CV != IS_CONST) {
48777
766
      zend_string_release_ex(op1_str, 0);
48778
766
    }
48779
766
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48780
766
      zend_string_release_ex(op2_str, 0);
48781
766
    }
48782
766
  } while (0);
48783
48784
1.15k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48785
1.15k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48786
1.15k
}
48787
48788
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48789
59
{
48790
59
  USE_OPLINE
48791
59
  zval *function_name;
48792
59
  zval *object;
48793
59
  zend_function *fbc;
48794
59
  zend_class_entry *called_scope;
48795
59
  zend_object *obj;
48796
59
  zend_execute_data *call;
48797
59
  uint32_t call_info;
48798
48799
59
  SAVE_OPLINE();
48800
48801
59
  object = EX_VAR(opline->op1.var);
48802
48803
59
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48804
59
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48805
59
  }
48806
48807
59
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
48808
59
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
48809
0
    do {
48810
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
48811
0
        function_name = Z_REFVAL_P(function_name);
48812
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
48813
0
          break;
48814
0
        }
48815
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
48816
0
        ZVAL_UNDEFINED_OP2();
48817
0
        if (UNEXPECTED(EG(exception) != NULL)) {
48818
48819
0
          HANDLE_EXCEPTION();
48820
0
        }
48821
0
      }
48822
0
      zend_throw_error(NULL, "Method name must be a string");
48823
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48824
48825
0
      HANDLE_EXCEPTION();
48826
0
    } while (0);
48827
0
  }
48828
48829
59
  if (IS_CV == IS_UNUSED) {
48830
0
    obj = Z_OBJ_P(object);
48831
59
  } else {
48832
59
    do {
48833
59
      if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
48834
59
        obj = Z_OBJ_P(object);
48835
59
      } else {
48836
0
        if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
48837
0
          zend_reference *ref = Z_REF_P(object);
48838
48839
0
          object = &ref->val;
48840
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
48841
0
            obj = Z_OBJ_P(object);
48842
0
            if (IS_CV & IS_VAR) {
48843
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
48844
0
                efree_size(ref, sizeof(zend_reference));
48845
0
              } else {
48846
0
                Z_ADDREF_P(object);
48847
0
              }
48848
0
            }
48849
0
            break;
48850
0
          }
48851
0
        }
48852
0
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
48853
0
          object = ZVAL_UNDEFINED_OP1();
48854
0
          if (UNEXPECTED(EG(exception) != NULL)) {
48855
0
            if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48856
0
              zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48857
0
            }
48858
0
            HANDLE_EXCEPTION();
48859
0
          }
48860
0
        }
48861
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48862
0
          function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48863
0
        }
48864
0
        zend_invalid_method_call(object, function_name);
48865
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48866
48867
0
        HANDLE_EXCEPTION();
48868
0
      }
48869
59
    } while (0);
48870
59
  }
48871
48872
59
  called_scope = obj->ce;
48873
48874
59
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
48875
59
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
48876
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
48877
59
  } else {
48878
59
    zend_object *orig_obj = obj;
48879
48880
59
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48881
0
      function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48882
0
    }
48883
48884
    /* First, locate the function. */
48885
59
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
48886
59
    if (UNEXPECTED(fbc == NULL)) {
48887
0
      if (EXPECTED(!EG(exception))) {
48888
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
48889
0
      }
48890
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48891
0
      if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
48892
0
        zend_objects_store_del(orig_obj);
48893
0
      }
48894
0
      HANDLE_EXCEPTION();
48895
0
    }
48896
59
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
48897
59
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
48898
59
        EXPECTED(obj == orig_obj)) {
48899
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
48900
0
    }
48901
59
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
48902
0
      GC_ADDREF(obj); /* For $this pointer */
48903
0
      if (GC_DELREF(orig_obj) == 0) {
48904
0
        zend_objects_store_del(orig_obj);
48905
0
      }
48906
0
    }
48907
59
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
48908
24
      init_func_run_time_cache(&fbc->op_array);
48909
24
    }
48910
59
  }
48911
48912
59
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48913
59
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48914
59
  }
48915
48916
59
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
48917
59
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
48918
0
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
48919
0
      zend_objects_store_del(obj);
48920
0
      if (UNEXPECTED(EG(exception))) {
48921
0
        HANDLE_EXCEPTION();
48922
0
      }
48923
0
    }
48924
    /* call static method */
48925
0
    obj = (zend_object*)called_scope;
48926
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
48927
59
  } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
48928
59
    if (IS_CV == IS_CV) {
48929
59
      GC_ADDREF(obj); /* For $this pointer */
48930
59
    }
48931
    /* CV may be changed indirectly (e.g. when it's a reference) */
48932
59
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
48933
59
  }
48934
48935
59
  call = zend_vm_stack_push_call_frame(call_info,
48936
59
    fbc, opline->extended_value, obj);
48937
59
  call->prev_execute_data = EX(call);
48938
59
  EX(call) = call;
48939
48940
59
  ZEND_VM_NEXT_OPCODE();
48941
59
}
48942
48943
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48944
4
{
48945
4
  USE_OPLINE
48946
4
  zval *expr_ptr, new_expr;
48947
48948
4
  SAVE_OPLINE();
48949
4
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
48950
4
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
48951
4
    expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
48952
4
    if (Z_ISREF_P(expr_ptr)) {
48953
0
      Z_ADDREF_P(expr_ptr);
48954
4
    } else {
48955
4
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
48956
4
    }
48957
48958
4
  } else {
48959
0
    expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48960
0
    if (IS_CV == IS_TMP_VAR) {
48961
      /* pass */
48962
0
    } else if (IS_CV == IS_CONST) {
48963
0
      Z_TRY_ADDREF_P(expr_ptr);
48964
0
    } else if (IS_CV == IS_CV) {
48965
0
      ZVAL_DEREF(expr_ptr);
48966
0
      Z_TRY_ADDREF_P(expr_ptr);
48967
0
    } else /* if (IS_CV == IS_VAR) */ {
48968
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
48969
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
48970
48971
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
48972
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
48973
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
48974
0
          expr_ptr = &new_expr;
48975
0
          efree_size(ref, sizeof(zend_reference));
48976
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
48977
0
          Z_ADDREF_P(expr_ptr);
48978
0
        }
48979
0
      }
48980
0
    }
48981
0
  }
48982
48983
4
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48984
4
    zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48985
4
    zend_string *str;
48986
4
    zend_ulong hval;
48987
48988
4
add_again:
48989
4
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
48990
0
      str = Z_STR_P(offset);
48991
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48992
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
48993
0
          goto num_index;
48994
0
        }
48995
0
      }
48996
0
str_index:
48997
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
48998
4
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
48999
4
      hval = Z_LVAL_P(offset);
49000
4
num_index:
49001
4
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
49002
4
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
49003
0
      offset = Z_REFVAL_P(offset);
49004
0
      goto add_again;
49005
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
49006
0
      str = ZSTR_EMPTY_ALLOC();
49007
0
      goto str_index;
49008
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
49009
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
49010
0
      goto num_index;
49011
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
49012
0
      hval = 0;
49013
0
      goto num_index;
49014
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
49015
0
      hval = 1;
49016
0
      goto num_index;
49017
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
49018
0
      zend_use_resource_as_offset(offset);
49019
0
      hval = Z_RES_HANDLE_P(offset);
49020
0
      goto num_index;
49021
0
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
49022
0
      ZVAL_UNDEFINED_OP2();
49023
0
      str = ZSTR_EMPTY_ALLOC();
49024
0
      goto str_index;
49025
0
    } else {
49026
0
      zend_illegal_array_offset_access(offset);
49027
0
      zval_ptr_dtor_nogc(expr_ptr);
49028
0
    }
49029
4
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49030
4
  } else {
49031
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
49032
0
      zend_cannot_add_element();
49033
0
      zval_ptr_dtor_nogc(expr_ptr);
49034
0
    }
49035
0
  }
49036
4
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49037
4
}
49038
49039
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49040
0
{
49041
0
  zval *array;
49042
0
  uint32_t size;
49043
0
  USE_OPLINE
49044
49045
0
  SAVE_OPLINE();
49046
0
  array = EX_VAR(opline->result.var);
49047
0
  if (IS_CV != IS_UNUSED) {
49048
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
49049
0
    ZVAL_ARR(array, zend_new_array(size));
49050
    /* Explicitly initialize array as not-packed if flag is set */
49051
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
49052
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
49053
0
    }
49054
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49055
0
  } else {
49056
0
    ZVAL_ARR(array, zend_new_array(0));
49057
0
    ZEND_VM_NEXT_OPCODE();
49058
0
  }
49059
0
}
49060
49061
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49062
207
{
49063
207
  USE_OPLINE
49064
207
  zval *container;
49065
207
  zval *offset;
49066
207
  zend_ulong hval;
49067
207
  zend_string *key;
49068
49069
207
  SAVE_OPLINE();
49070
207
  container = EX_VAR(opline->op1.var);
49071
207
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49072
49073
207
  do {
49074
207
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49075
167
      HashTable *ht;
49076
49077
167
unset_dim_array:
49078
167
      SEPARATE_ARRAY(container);
49079
167
      ht = Z_ARRVAL_P(container);
49080
167
offset_again:
49081
167
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49082
3
        key = Z_STR_P(offset);
49083
3
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49084
3
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
49085
0
            goto num_index_dim;
49086
0
          }
49087
3
        }
49088
6
str_index_dim:
49089
6
        ZEND_ASSERT(ht != &EG(symbol_table));
49090
6
        zend_hash_del(ht, key);
49091
164
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49092
124
        hval = Z_LVAL_P(offset);
49093
161
num_index_dim:
49094
161
        zend_hash_index_del(ht, hval);
49095
161
      } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
49096
0
        offset = Z_REFVAL_P(offset);
49097
0
        goto offset_again;
49098
40
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
49099
37
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
49100
37
        goto num_index_dim;
49101
37
      } else if (Z_TYPE_P(offset) == IS_NULL) {
49102
3
        key = ZSTR_EMPTY_ALLOC();
49103
3
        goto str_index_dim;
49104
3
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
49105
0
        hval = 0;
49106
0
        goto num_index_dim;
49107
0
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
49108
0
        hval = 1;
49109
0
        goto num_index_dim;
49110
0
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
49111
0
        zend_use_resource_as_offset(offset);
49112
0
        hval = Z_RES_HANDLE_P(offset);
49113
0
        goto num_index_dim;
49114
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
49115
0
        ZVAL_UNDEFINED_OP2();
49116
0
        key = ZSTR_EMPTY_ALLOC();
49117
0
        goto str_index_dim;
49118
0
      } else {
49119
0
        zend_illegal_array_offset_unset(offset);
49120
0
      }
49121
167
      break;
49122
167
    } else if (Z_ISREF_P(container)) {
49123
0
      container = Z_REFVAL_P(container);
49124
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49125
0
        goto unset_dim_array;
49126
0
      }
49127
0
    }
49128
40
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
49129
3
      container = ZVAL_UNDEFINED_OP1();
49130
3
    }
49131
40
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
49132
0
      offset = ZVAL_UNDEFINED_OP2();
49133
0
    }
49134
40
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
49135
37
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
49136
0
        offset++;
49137
0
      }
49138
37
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
49139
37
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
49140
0
      zend_throw_error(NULL, "Cannot unset string offsets");
49141
3
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
49142
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
49143
3
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
49144
0
      zend_false_to_array_deprecated();
49145
0
    }
49146
40
  } while (0);
49147
49148
207
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49149
49150
207
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49151
207
}
49152
49153
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49154
0
{
49155
0
  USE_OPLINE
49156
0
  zval *container;
49157
0
  zval *offset;
49158
0
  zend_string *name, *tmp_name;
49159
49160
0
  SAVE_OPLINE();
49161
0
  container = EX_VAR(opline->op1.var);
49162
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49163
49164
0
  do {
49165
0
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
49166
0
      if (Z_ISREF_P(container)) {
49167
0
        container = Z_REFVAL_P(container);
49168
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
49169
0
          if (IS_CV == IS_CV
49170
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
49171
0
            ZVAL_UNDEFINED_OP1();
49172
0
          }
49173
0
          break;
49174
0
        }
49175
0
      } else {
49176
0
        break;
49177
0
      }
49178
0
    }
49179
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
49180
0
      name = Z_STR_P(offset);
49181
0
    } else {
49182
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
49183
0
      if (UNEXPECTED(!name)) {
49184
0
        break;
49185
0
      }
49186
0
    }
49187
0
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
49188
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49189
0
      zend_tmp_string_release(tmp_name);
49190
0
    }
49191
0
  } while (0);
49192
49193
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49194
49195
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49196
0
}
49197
49198
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49199
215
{
49200
215
  USE_OPLINE
49201
215
  zval *container;
49202
215
  bool result;
49203
215
  zend_ulong hval;
49204
215
  zval *offset;
49205
49206
215
  SAVE_OPLINE();
49207
215
  container = EX_VAR(opline->op1.var);
49208
215
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49209
49210
215
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49211
27
    HashTable *ht;
49212
27
    zval *value;
49213
27
    zend_string *str;
49214
49215
27
isset_dim_obj_array:
49216
27
    ht = Z_ARRVAL_P(container);
49217
27
isset_again:
49218
27
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49219
0
      str = Z_STR_P(offset);
49220
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49221
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
49222
0
          goto num_index_prop;
49223
0
        }
49224
0
      }
49225
0
      value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
49226
27
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49227
0
      hval = Z_LVAL_P(offset);
49228
0
num_index_prop:
49229
0
      value = zend_hash_index_find(ht, hval);
49230
27
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
49231
0
      offset = Z_REFVAL_P(offset);
49232
0
      goto isset_again;
49233
27
    } else {
49234
27
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
49235
27
      if (UNEXPECTED(EG(exception))) {
49236
27
        result = 0;
49237
27
        goto isset_dim_obj_exit;
49238
27
      }
49239
27
    }
49240
49241
0
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
49242
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
49243
0
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
49244
0
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
49245
49246
0
      if (IS_CV & (IS_CONST|IS_CV)) {
49247
        /* avoid exception check */
49248
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49249
0
        ZEND_VM_SMART_BRANCH(result, 0);
49250
0
      }
49251
0
    } else {
49252
0
      result = (value == NULL || !i_zend_is_true(value));
49253
0
    }
49254
0
    goto isset_dim_obj_exit;
49255
188
  } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
49256
0
    container = Z_REFVAL_P(container);
49257
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49258
0
      goto isset_dim_obj_array;
49259
0
    }
49260
0
  }
49261
49262
188
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
49263
0
    offset++;
49264
0
  }
49265
188
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
49266
105
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
49267
105
  } else {
49268
83
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
49269
83
  }
49270
49271
215
isset_dim_obj_exit:
49272
215
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49273
49274
215
  ZEND_VM_SMART_BRANCH(result, 1);
49275
215
}
49276
49277
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49278
0
{
49279
0
  USE_OPLINE
49280
0
  zval *container;
49281
0
  int result;
49282
0
  zval *offset;
49283
0
  zend_string *name, *tmp_name;
49284
49285
0
  SAVE_OPLINE();
49286
0
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
49287
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49288
49289
0
  if (IS_CV == IS_CONST ||
49290
0
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
49291
0
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
49292
0
      container = Z_REFVAL_P(container);
49293
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
49294
0
        result = (opline->extended_value & ZEND_ISEMPTY);
49295
0
        goto isset_object_finish;
49296
0
      }
49297
0
    } else {
49298
0
      result = (opline->extended_value & ZEND_ISEMPTY);
49299
0
      goto isset_object_finish;
49300
0
    }
49301
0
  }
49302
49303
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
49304
0
    name = Z_STR_P(offset);
49305
0
  } else {
49306
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
49307
0
    if (UNEXPECTED(!name)) {
49308
0
      result = 0;
49309
0
      goto isset_object_finish;
49310
0
    }
49311
0
  }
49312
49313
0
  result =
49314
0
    (opline->extended_value & ZEND_ISEMPTY) ^
49315
0
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
49316
49317
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49318
0
    zend_tmp_string_release(tmp_name);
49319
0
  }
49320
49321
0
isset_object_finish:
49322
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49323
49324
0
  ZEND_VM_SMART_BRANCH(result, 1);
49325
0
}
49326
49327
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49328
344
{
49329
344
  USE_OPLINE
49330
49331
344
  zval *key, *subject;
49332
344
  HashTable *ht;
49333
344
  bool result;
49334
49335
344
  SAVE_OPLINE();
49336
49337
344
  key = EX_VAR(opline->op1.var);
49338
344
  subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49339
49340
344
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
49341
339
array_key_exists_array:
49342
339
    ht = Z_ARRVAL_P(subject);
49343
339
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
49344
339
  } else {
49345
5
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
49346
0
      subject = Z_REFVAL_P(subject);
49347
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
49348
0
        goto array_key_exists_array;
49349
0
      }
49350
0
    }
49351
5
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
49352
5
    result = 0;
49353
5
  }
49354
49355
344
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49356
49357
344
  ZEND_VM_SMART_BRANCH(result, 1);
49358
344
}
49359
49360
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49361
0
{
49362
0
  USE_OPLINE
49363
49364
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
49365
49366
0
  SAVE_OPLINE();
49367
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
49368
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49369
0
  }
49370
49371
  /* Destroy the previously yielded value */
49372
0
  zval_ptr_dtor(&generator->value);
49373
49374
  /* Destroy the previously yielded key */
49375
0
  zval_ptr_dtor(&generator->key);
49376
49377
  /* Set the new yielded value */
49378
0
  if (IS_CV != IS_UNUSED) {
49379
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
49380
      /* Constants and temporary variables aren't yieldable by reference,
49381
       * but we still allow them with a notice. */
49382
0
      if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
49383
0
        zval *value;
49384
49385
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49386
49387
0
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49388
0
        ZVAL_COPY_VALUE(&generator->value, value);
49389
0
        if (IS_CV == IS_CONST) {
49390
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49391
0
            Z_ADDREF(generator->value);
49392
0
          }
49393
0
        }
49394
0
      } else {
49395
0
        zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49396
49397
        /* If a function call result is yielded and the function did
49398
         * not return by reference we throw a notice. */
49399
0
        do {
49400
0
          if (IS_CV == IS_VAR) {
49401
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
49402
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
49403
0
             && !Z_ISREF_P(value_ptr)) {
49404
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49405
0
              ZVAL_COPY(&generator->value, value_ptr);
49406
0
              break;
49407
0
            }
49408
0
          }
49409
0
          if (Z_ISREF_P(value_ptr)) {
49410
0
            Z_ADDREF_P(value_ptr);
49411
0
          } else {
49412
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
49413
0
          }
49414
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
49415
0
        } while (0);
49416
49417
0
      }
49418
0
    } else {
49419
0
      zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49420
49421
      /* Consts, temporary variables and references need copying */
49422
0
      if (IS_CV == IS_CONST) {
49423
0
        ZVAL_COPY_VALUE(&generator->value, value);
49424
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49425
0
          Z_ADDREF(generator->value);
49426
0
        }
49427
0
      } else if (IS_CV == IS_TMP_VAR) {
49428
0
        ZVAL_COPY_VALUE(&generator->value, value);
49429
0
      } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
49430
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
49431
49432
0
      } else {
49433
0
        ZVAL_COPY_VALUE(&generator->value, value);
49434
0
        if (IS_CV == IS_CV) {
49435
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
49436
0
        }
49437
0
      }
49438
0
    }
49439
0
  } else {
49440
    /* If no value was specified yield null */
49441
0
    ZVAL_NULL(&generator->value);
49442
0
  }
49443
49444
  /* Set the new yielded key */
49445
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
49446
0
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49447
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
49448
0
      key = Z_REFVAL_P(key);
49449
0
    }
49450
0
    ZVAL_COPY(&generator->key, key);
49451
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49452
49453
0
    if (Z_TYPE(generator->key) == IS_LONG
49454
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
49455
0
    ) {
49456
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
49457
0
    }
49458
0
  } else {
49459
    /* If no key was specified we use auto-increment keys */
49460
0
    generator->largest_used_integer_key++;
49461
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
49462
0
  }
49463
49464
0
  if (RETURN_VALUE_USED(opline)) {
49465
    /* If the return value of yield is used set the send
49466
     * target and initialize it to NULL */
49467
0
    generator->send_target = EX_VAR(opline->result.var);
49468
0
    ZVAL_NULL(generator->send_target);
49469
0
  } else {
49470
0
    generator->send_target = NULL;
49471
0
  }
49472
49473
  /* The GOTO VM uses a local opline variable. We need to set the opline
49474
   * variable in execute_data so we don't resume at an old position. */
49475
0
  SAVE_OPLINE();
49476
49477
0
  ZEND_VM_RETURN();
49478
0
}
49479
49480
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49481
1.04k
{
49482
1.04k
  USE_OPLINE
49483
1.04k
  zval *op1, *op2;
49484
1.04k
  bool result;
49485
49486
1.04k
  SAVE_OPLINE();
49487
1.04k
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49488
1.04k
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49489
1.04k
  result = fast_is_identical_function(op1, op2);
49490
49491
1.04k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49492
1.04k
  ZEND_VM_SMART_BRANCH(result, 1);
49493
1.04k
}
49494
49495
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49496
0
{
49497
0
  USE_OPLINE
49498
0
  zval *op1, *op2;
49499
0
  bool result;
49500
49501
0
  SAVE_OPLINE();
49502
0
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49503
0
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49504
0
  result = fast_is_not_identical_function(op1, op2);
49505
49506
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49507
0
  ZEND_VM_SMART_BRANCH(result, 1);
49508
0
}
49509
49510
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49511
121k
{
49512
121k
  USE_OPLINE
49513
121k
  zval *value;
49514
121k
  zval *variable_ptr;
49515
49516
121k
  SAVE_OPLINE();
49517
121k
  value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49518
121k
  variable_ptr = EX_VAR(opline->op1.var);
49519
49520
121k
  if (0 || UNEXPECTED(0)) {
49521
0
    zend_refcounted *garbage = NULL;
49522
49523
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
49524
0
    if (UNEXPECTED(0)) {
49525
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
49526
0
    }
49527
0
    if (garbage) {
49528
0
      GC_DTOR_NO_REF(garbage);
49529
0
    }
49530
121k
  } else {
49531
121k
    value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
49532
121k
  }
49533
49534
  /* zend_assign_to_variable() always takes care of op2, never free it! */
49535
49536
121k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49537
121k
}
49538
49539
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49540
945k
{
49541
945k
  USE_OPLINE
49542
945k
  zval *value;
49543
945k
  zval *variable_ptr;
49544
49545
945k
  SAVE_OPLINE();
49546
945k
  value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49547
945k
  variable_ptr = EX_VAR(opline->op1.var);
49548
49549
945k
  if (0 || UNEXPECTED(1)) {
49550
945k
    zend_refcounted *garbage = NULL;
49551
49552
945k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
49553
945k
    if (UNEXPECTED(1)) {
49554
945k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
49555
945k
    }
49556
945k
    if (garbage) {
49557
286k
      GC_DTOR_NO_REF(garbage);
49558
286k
    }
49559
945k
  } else {
49560
0
    value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
49561
0
  }
49562
49563
  /* zend_assign_to_variable() always takes care of op2, never free it! */
49564
49565
945k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49566
945k
}
49567
49568
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49569
99
{
49570
99
  USE_OPLINE
49571
99
  zval *op1, *op2;
49572
99
  bool result;
49573
49574
99
  SAVE_OPLINE();
49575
99
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49576
99
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
49577
99
  result = fast_is_identical_function(op1, op2);
49578
49579
99
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49580
99
  ZEND_VM_SMART_BRANCH(result, 1);
49581
99
}
49582
49583
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49584
43
{
49585
43
  USE_OPLINE
49586
43
  zval *op1, *op2;
49587
43
  bool result;
49588
49589
43
  SAVE_OPLINE();
49590
43
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49591
43
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
49592
43
  result = fast_is_not_identical_function(op1, op2);
49593
49594
43
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49595
43
  ZEND_VM_SMART_BRANCH(result, 1);
49596
43
}
49597
49598
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49599
422k
{
49600
422k
  USE_OPLINE
49601
422k
  zval *value;
49602
422k
  zval *variable_ptr;
49603
49604
422k
  SAVE_OPLINE();
49605
422k
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49606
422k
  variable_ptr = EX_VAR(opline->op1.var);
49607
49608
422k
  if (0 || UNEXPECTED(0)) {
49609
0
    zend_refcounted *garbage = NULL;
49610
49611
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
49612
0
    if (UNEXPECTED(0)) {
49613
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
49614
0
    }
49615
0
    if (garbage) {
49616
0
      GC_DTOR_NO_REF(garbage);
49617
0
    }
49618
422k
  } else {
49619
422k
    value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
49620
422k
  }
49621
49622
  /* zend_assign_to_variable() always takes care of op2, never free it! */
49623
49624
422k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49625
422k
}
49626
49627
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49628
1.06k
{
49629
1.06k
  USE_OPLINE
49630
1.06k
  zval *value;
49631
1.06k
  zval *variable_ptr;
49632
49633
1.06k
  SAVE_OPLINE();
49634
1.06k
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49635
1.06k
  variable_ptr = EX_VAR(opline->op1.var);
49636
49637
1.06k
  if (0 || UNEXPECTED(1)) {
49638
1.06k
    zend_refcounted *garbage = NULL;
49639
49640
1.06k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
49641
1.06k
    if (UNEXPECTED(1)) {
49642
1.06k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
49643
1.06k
    }
49644
1.06k
    if (garbage) {
49645
638
      GC_DTOR_NO_REF(garbage);
49646
638
    }
49647
1.06k
  } else {
49648
0
    value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
49649
0
  }
49650
49651
  /* zend_assign_to_variable() always takes care of op2, never free it! */
49652
49653
1.06k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49654
1.06k
}
49655
49656
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49657
2.88k
{
49658
2.88k
  USE_OPLINE
49659
2.88k
  zval *variable_ptr;
49660
2.88k
  zval *value_ptr;
49661
2.88k
  zend_refcounted *garbage = NULL;
49662
49663
2.88k
  SAVE_OPLINE();
49664
2.88k
  value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49665
2.88k
  variable_ptr = EX_VAR(opline->op1.var);
49666
49667
2.88k
  if (IS_CV == IS_VAR &&
49668
2.88k
             UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
49669
49670
0
    zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
49671
0
    variable_ptr = &EG(uninitialized_zval);
49672
2.88k
  } else if (IS_VAR == IS_VAR &&
49673
2.88k
             opline->extended_value == ZEND_RETURNS_FUNCTION &&
49674
2.88k
         UNEXPECTED(!Z_ISREF_P(value_ptr))) {
49675
49676
44
    variable_ptr = zend_wrong_assign_to_variable_reference(
49677
44
      variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
49678
2.84k
  } else {
49679
2.84k
    zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
49680
2.84k
  }
49681
49682
2.88k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49683
169
    ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
49684
169
  }
49685
49686
2.88k
  if (garbage) {
49687
1.76k
    GC_DTOR(garbage);
49688
1.76k
  }
49689
49690
2.88k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49691
49692
2.88k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49693
2.88k
}
49694
49695
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49696
15
{
49697
15
  USE_OPLINE
49698
15
  zval *expr;
49699
15
  bool result;
49700
49701
15
  SAVE_OPLINE();
49702
15
  expr = EX_VAR(opline->op1.var);
49703
49704
15
try_instanceof:
49705
15
  if (Z_TYPE_P(expr) == IS_OBJECT) {
49706
10
    zend_class_entry *ce;
49707
49708
10
    if (IS_VAR == IS_CONST) {
49709
0
      ce = CACHED_PTR(opline->extended_value);
49710
0
      if (UNEXPECTED(ce == NULL)) {
49711
0
        ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD);
49712
0
        if (EXPECTED(ce)) {
49713
0
          CACHE_PTR(opline->extended_value, ce);
49714
0
        }
49715
0
      }
49716
10
    } else if (IS_VAR == IS_UNUSED) {
49717
0
      ce = zend_fetch_class(NULL, opline->op2.num);
49718
0
      if (UNEXPECTED(ce == NULL)) {
49719
49720
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
49721
0
        HANDLE_EXCEPTION();
49722
0
      }
49723
10
    } else {
49724
10
      ce = Z_CE_P(EX_VAR(opline->op2.var));
49725
10
    }
49726
10
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
49727
10
  } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
49728
0
    expr = Z_REFVAL_P(expr);
49729
0
    goto try_instanceof;
49730
5
  } else {
49731
5
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
49732
5
      ZVAL_UNDEFINED_OP1();
49733
5
    }
49734
5
    result = 0;
49735
5
  }
49736
49737
15
  ZEND_VM_SMART_BRANCH(result, 1);
49738
15
}
49739
49740
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49741
756
{
49742
756
  USE_OPLINE
49743
756
  zval *var_ptr;
49744
756
  zval *value, *container, *dim;
49745
756
  HashTable *ht;
49746
49747
756
  SAVE_OPLINE();
49748
756
  container = EX_VAR(opline->op1.var);
49749
49750
756
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49751
501
assign_dim_op_array:
49752
501
    SEPARATE_ARRAY(container);
49753
501
    ht = Z_ARRVAL_P(container);
49754
744
assign_dim_op_new_array:
49755
744
    dim = NULL;
49756
744
    if (IS_UNUSED == IS_UNUSED) {
49757
744
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
49758
744
      if (UNEXPECTED(!var_ptr)) {
49759
21
        zend_cannot_add_element();
49760
21
        goto assign_dim_op_ret_null;
49761
21
      }
49762
744
    } else {
49763
0
      if (IS_UNUSED == IS_CONST) {
49764
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
49765
0
      } else {
49766
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
49767
0
      }
49768
0
      if (UNEXPECTED(!var_ptr)) {
49769
0
        goto assign_dim_op_ret_null;
49770
0
      }
49771
0
    }
49772
49773
723
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
49774
49775
723
    do {
49776
723
      if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
49777
0
        zend_reference *ref = Z_REF_P(var_ptr);
49778
0
        var_ptr = Z_REFVAL_P(var_ptr);
49779
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
49780
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
49781
0
          break;
49782
0
        }
49783
0
      }
49784
723
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
49785
723
    } while (0);
49786
49787
723
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49788
8
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
49789
8
    }
49790
723
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
49791
723
  } else {
49792
255
    if (EXPECTED(Z_ISREF_P(container))) {
49793
0
      container = Z_REFVAL_P(container);
49794
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49795
0
        goto assign_dim_op_array;
49796
0
      }
49797
0
    }
49798
49799
255
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
49800
7
      zend_object *obj = Z_OBJ_P(container);
49801
49802
7
      dim = NULL;
49803
7
      if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
49804
0
        dim++;
49805
0
      }
49806
7
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
49807
248
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
49808
243
      uint8_t old_type;
49809
49810
243
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
49811
29
        ZVAL_UNDEFINED_OP1();
49812
29
      }
49813
243
      ht = zend_new_array(8);
49814
243
      old_type = Z_TYPE_P(container);
49815
243
      ZVAL_ARR(container, ht);
49816
243
      if (UNEXPECTED(old_type == IS_FALSE)) {
49817
10
        GC_ADDREF(ht);
49818
10
        zend_false_to_array_deprecated();
49819
10
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
49820
0
          zend_array_destroy(ht);
49821
0
          goto assign_dim_op_ret_null;
49822
0
        }
49823
10
      }
49824
243
      goto assign_dim_op_new_array;
49825
243
    } else {
49826
5
      dim = NULL;
49827
5
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
49828
26
assign_dim_op_ret_null:
49829
26
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
49830
26
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49831
21
        ZVAL_NULL(EX_VAR(opline->result.var));
49832
21
      }
49833
26
    }
49834
255
  }
49835
49836
49837
756
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
49838
756
}
49839
49840
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_EX int type)
49841
34.7k
{
49842
34.7k
  USE_OPLINE
49843
34.7k
  zval *varname;
49844
34.7k
  zval *retval;
49845
34.7k
  zend_string *name, *tmp_name;
49846
34.7k
  HashTable *target_symbol_table;
49847
49848
34.7k
  SAVE_OPLINE();
49849
34.7k
  varname = EX_VAR(opline->op1.var);
49850
49851
34.7k
  if (IS_CV == IS_CONST) {
49852
0
    name = Z_STR_P(varname);
49853
34.7k
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
49854
6.68k
    name = Z_STR_P(varname);
49855
6.68k
    tmp_name = NULL;
49856
28.0k
  } else {
49857
28.0k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
49858
13.8k
      ZVAL_UNDEFINED_OP1();
49859
13.8k
    }
49860
28.0k
    name = zval_try_get_tmp_string(varname, &tmp_name);
49861
28.0k
    if (UNEXPECTED(!name)) {
49862
261
      if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
49863
49864
261
      }
49865
261
      ZVAL_UNDEF(EX_VAR(opline->result.var));
49866
261
      HANDLE_EXCEPTION();
49867
261
    }
49868
28.0k
  }
49869
49870
34.5k
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
49871
34.5k
  retval = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
49872
34.5k
  if (retval == NULL) {
49873
19.3k
    if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
49874
15
fetch_this:
49875
15
      zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
49876
15
      if (IS_CV != IS_CONST) {
49877
15
        zend_tmp_string_release(tmp_name);
49878
15
      }
49879
15
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49880
15
    }
49881
19.3k
    if (type == BP_VAR_W) {
49882
8.57k
      retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
49883
10.8k
    } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
49884
10
      retval = &EG(uninitialized_zval);
49885
10.7k
    } else {
49886
10.7k
      if (IS_CV == IS_CV) {
49887
        /* Keep name alive in case an error handler tries to free it. */
49888
10.7k
        zend_string_addref(name);
49889
10.7k
      }
49890
10.7k
      zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
49891
10.7k
        (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
49892
10.7k
      if (type == BP_VAR_RW && !EG(exception)) {
49893
4.16k
        retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
49894
6.63k
      } else {
49895
6.63k
        retval = &EG(uninitialized_zval);
49896
6.63k
      }
49897
10.7k
      if (IS_CV == IS_CV) {
49898
10.7k
        zend_string_release(name);
49899
10.7k
      }
49900
10.7k
    }
49901
  /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
49902
19.3k
  } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
49903
191
    retval = Z_INDIRECT_P(retval);
49904
191
    if (Z_TYPE_P(retval) == IS_UNDEF) {
49905
24
      if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
49906
0
        goto fetch_this;
49907
0
      }
49908
24
      if (type == BP_VAR_W) {
49909
12
        ZVAL_NULL(retval);
49910
12
      } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
49911
0
        retval = &EG(uninitialized_zval);
49912
12
      } else {
49913
12
        zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
49914
12
          (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
49915
12
        if (type == BP_VAR_RW && !EG(exception)) {
49916
0
          ZVAL_NULL(retval);
49917
12
        } else {
49918
12
          retval = &EG(uninitialized_zval);
49919
12
        }
49920
12
      }
49921
24
    }
49922
191
  }
49923
49924
34.5k
  if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
49925
49926
34.5k
  }
49927
49928
34.5k
  if (IS_CV != IS_CONST) {
49929
34.5k
    zend_tmp_string_release(tmp_name);
49930
34.5k
  }
49931
49932
34.5k
  ZEND_ASSERT(retval != NULL);
49933
34.5k
  if (type == BP_VAR_R || type == BP_VAR_IS) {
49934
8.87k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
49935
25.6k
  } else {
49936
25.6k
    ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
49937
25.6k
  }
49938
34.5k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49939
34.5k
}
49940
49941
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49942
8.35k
{
49943
8.35k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R));
49944
8.35k
}
49945
49946
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49947
14.8k
{
49948
14.8k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W));
49949
14.8k
}
49950
49951
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49952
10.9k
{
49953
10.9k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW));
49954
10.9k
}
49955
49956
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49957
531
{
49958
531
  int fetch_type =
49959
531
    (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
49960
531
      BP_VAR_W : BP_VAR_R;
49961
531
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type));
49962
531
}
49963
49964
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49965
0
{
49966
0
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET));
49967
0
}
49968
49969
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49970
10
{
49971
10
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS));
49972
10
}
49973
49974
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
49975
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49976
1.87k
{
49977
1.87k
  USE_OPLINE
49978
1.87k
  zval *container;
49979
49980
1.87k
  SAVE_OPLINE();
49981
1.87k
  container = EX_VAR(opline->op1.var);
49982
1.87k
  zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
49983
49984
1.87k
  if (IS_CV == IS_VAR) {
49985
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
49986
0
  }
49987
1.87k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49988
1.87k
}
49989
49990
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49991
35
{
49992
35
  USE_OPLINE
49993
35
  zval *container;
49994
49995
35
  SAVE_OPLINE();
49996
35
  container = EX_VAR(opline->op1.var);
49997
35
  zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
49998
49999
35
  if (IS_CV == IS_VAR) {
50000
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
50001
0
  }
50002
35
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50003
35
}
50004
50005
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50006
10
{
50007
#if 0
50008
  USE_OPLINE
50009
#endif
50010
50011
10
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
50012
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
50013
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50014
0
    }
50015
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50016
10
  } else {
50017
10
    if (IS_UNUSED == IS_UNUSED) {
50018
10
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50019
10
    }
50020
10
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50021
10
  }
50022
10
}
50023
50024
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50025
3.37k
{
50026
3.37k
  USE_OPLINE
50027
3.37k
  zval *object_ptr, *orig_object_ptr;
50028
3.37k
  zval *value;
50029
3.37k
  zval *variable_ptr;
50030
3.37k
  zval *dim;
50031
3.37k
  zend_refcounted *garbage = NULL;
50032
50033
3.37k
  SAVE_OPLINE();
50034
3.37k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50035
50036
3.37k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50037
3.32k
try_assign_dim_array:
50038
3.32k
    SEPARATE_ARRAY(object_ptr);
50039
3.32k
    if (IS_UNUSED == IS_UNUSED) {
50040
3.32k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
50041
3.32k
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50042
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
50043
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50044
0
          GC_ADDREF(ht);
50045
0
        }
50046
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50047
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50048
0
          zend_array_destroy(ht);
50049
0
          goto assign_dim_error;
50050
0
        }
50051
0
      }
50052
3.32k
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
50053
0
        ZVAL_DEREF(value);
50054
0
      }
50055
3.32k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50056
3.32k
      if (UNEXPECTED(value == NULL)) {
50057
21
        zend_cannot_add_element();
50058
21
        goto assign_dim_error;
50059
3.30k
      } else if (IS_CONST == IS_CV) {
50060
0
        if (Z_REFCOUNTED_P(value)) {
50061
0
          Z_ADDREF_P(value);
50062
0
        }
50063
3.30k
      } else if (IS_CONST == IS_VAR) {
50064
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
50065
0
        if (Z_ISREF_P(free_op_data)) {
50066
0
          if (Z_REFCOUNTED_P(value)) {
50067
0
            Z_ADDREF_P(value);
50068
0
          }
50069
0
          zval_ptr_dtor_nogc(free_op_data);
50070
0
        }
50071
3.30k
      } else if (IS_CONST == IS_CONST) {
50072
3.30k
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50073
0
          Z_ADDREF_P(value);
50074
0
        }
50075
3.30k
      }
50076
3.32k
    } else {
50077
0
      dim = NULL;
50078
0
      if (IS_UNUSED == IS_CONST) {
50079
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50080
0
      } else {
50081
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50082
0
      }
50083
0
      if (UNEXPECTED(variable_ptr == NULL)) {
50084
0
        goto assign_dim_error;
50085
0
      }
50086
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
50087
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
50088
0
    }
50089
3.30k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50090
12
      ZVAL_COPY(EX_VAR(opline->result.var), value);
50091
12
    }
50092
3.30k
    if (garbage) {
50093
0
      GC_DTOR_NO_REF(garbage);
50094
0
    }
50095
3.30k
  } else {
50096
1.04k
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
50097
816
      object_ptr = Z_REFVAL_P(object_ptr);
50098
816
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50099
734
        goto try_assign_dim_array;
50100
734
      }
50101
816
    }
50102
314
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50103
15
      zend_object *obj = Z_OBJ_P(object_ptr);
50104
50105
15
      GC_ADDREF(obj);
50106
15
      dim = NULL;
50107
15
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50108
0
        dim = ZVAL_UNDEFINED_OP2();
50109
15
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50110
0
        dim++;
50111
0
      }
50112
50113
15
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
50114
15
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50115
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50116
15
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
50117
0
        ZVAL_DEREF(value);
50118
0
      }
50119
50120
15
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50121
50122
15
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50123
0
        zend_objects_store_del(obj);
50124
0
      }
50125
299
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50126
23
      if (IS_UNUSED == IS_UNUSED) {
50127
23
        zend_use_new_element_for_string();
50128
50129
23
        UNDEF_RESULT();
50130
23
      } else {
50131
0
        dim = NULL;
50132
0
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
50133
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50134
50135
0
      }
50136
276
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50137
276
      if (Z_ISREF_P(orig_object_ptr)
50138
276
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50139
276
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50140
5
        dim = NULL;
50141
50142
5
        UNDEF_RESULT();
50143
271
      } else {
50144
271
        HashTable *ht = zend_new_array(8);
50145
271
        uint8_t old_type = Z_TYPE_P(object_ptr);
50146
50147
271
        ZVAL_ARR(object_ptr, ht);
50148
271
        if (UNEXPECTED(old_type == IS_FALSE)) {
50149
161
          GC_ADDREF(ht);
50150
161
          zend_false_to_array_deprecated();
50151
161
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50152
7
            zend_array_destroy(ht);
50153
7
            goto assign_dim_error;
50154
7
          }
50155
161
        }
50156
264
        goto try_assign_dim_array;
50157
271
      }
50158
276
    } else {
50159
0
      zend_use_scalar_as_array();
50160
0
      dim = NULL;
50161
28
assign_dim_error:
50162
50163
28
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50164
8
        ZVAL_NULL(EX_VAR(opline->result.var));
50165
8
      }
50166
28
    }
50167
314
  }
50168
3.37k
  if (IS_UNUSED != IS_UNUSED) {
50169
50170
0
  }
50171
50172
  /* assign_dim has two opcodes! */
50173
3.37k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
50174
3.37k
}
50175
50176
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50177
1.48k
{
50178
1.48k
  USE_OPLINE
50179
1.48k
  zval *object_ptr, *orig_object_ptr;
50180
1.48k
  zval *value;
50181
1.48k
  zval *variable_ptr;
50182
1.48k
  zval *dim;
50183
1.48k
  zend_refcounted *garbage = NULL;
50184
50185
1.48k
  SAVE_OPLINE();
50186
1.48k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50187
50188
1.48k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50189
1.47k
try_assign_dim_array:
50190
1.47k
    SEPARATE_ARRAY(object_ptr);
50191
1.47k
    if (IS_UNUSED == IS_UNUSED) {
50192
1.47k
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50193
1.47k
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50194
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
50195
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50196
0
          GC_ADDREF(ht);
50197
0
        }
50198
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50199
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50200
0
          zend_array_destroy(ht);
50201
0
          goto assign_dim_error;
50202
0
        }
50203
0
      }
50204
1.47k
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
50205
0
        ZVAL_DEREF(value);
50206
0
      }
50207
1.47k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50208
1.47k
      if (UNEXPECTED(value == NULL)) {
50209
3
        zend_cannot_add_element();
50210
3
        goto assign_dim_error;
50211
1.47k
      } else if (IS_TMP_VAR == IS_CV) {
50212
0
        if (Z_REFCOUNTED_P(value)) {
50213
0
          Z_ADDREF_P(value);
50214
0
        }
50215
1.47k
      } else if (IS_TMP_VAR == IS_VAR) {
50216
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
50217
0
        if (Z_ISREF_P(free_op_data)) {
50218
0
          if (Z_REFCOUNTED_P(value)) {
50219
0
            Z_ADDREF_P(value);
50220
0
          }
50221
0
          zval_ptr_dtor_nogc(free_op_data);
50222
0
        }
50223
1.47k
      } else if (IS_TMP_VAR == IS_CONST) {
50224
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50225
0
          Z_ADDREF_P(value);
50226
0
        }
50227
0
      }
50228
1.47k
    } else {
50229
0
      dim = NULL;
50230
0
      if (IS_UNUSED == IS_CONST) {
50231
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50232
0
      } else {
50233
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50234
0
      }
50235
0
      if (UNEXPECTED(variable_ptr == NULL)) {
50236
0
        goto assign_dim_error;
50237
0
      }
50238
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50239
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
50240
0
    }
50241
1.47k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50242
106
      ZVAL_COPY(EX_VAR(opline->result.var), value);
50243
106
    }
50244
1.47k
    if (garbage) {
50245
0
      GC_DTOR_NO_REF(garbage);
50246
0
    }
50247
1.47k
  } else {
50248
106
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
50249
69
      object_ptr = Z_REFVAL_P(object_ptr);
50250
69
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50251
57
        goto try_assign_dim_array;
50252
57
      }
50253
69
    }
50254
49
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50255
0
      zend_object *obj = Z_OBJ_P(object_ptr);
50256
50257
0
      GC_ADDREF(obj);
50258
0
      dim = NULL;
50259
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50260
0
        dim = ZVAL_UNDEFINED_OP2();
50261
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50262
0
        dim++;
50263
0
      }
50264
50265
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50266
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50267
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50268
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
50269
0
        ZVAL_DEREF(value);
50270
0
      }
50271
50272
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50273
50274
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50275
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50276
0
        zend_objects_store_del(obj);
50277
0
      }
50278
49
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50279
0
      if (IS_UNUSED == IS_UNUSED) {
50280
0
        zend_use_new_element_for_string();
50281
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50282
0
        UNDEF_RESULT();
50283
0
      } else {
50284
0
        dim = NULL;
50285
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50286
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50287
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50288
0
      }
50289
49
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50290
42
      if (Z_ISREF_P(orig_object_ptr)
50291
42
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50292
42
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50293
0
        dim = NULL;
50294
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50295
0
        UNDEF_RESULT();
50296
42
      } else {
50297
42
        HashTable *ht = zend_new_array(8);
50298
42
        uint8_t old_type = Z_TYPE_P(object_ptr);
50299
50300
42
        ZVAL_ARR(object_ptr, ht);
50301
42
        if (UNEXPECTED(old_type == IS_FALSE)) {
50302
0
          GC_ADDREF(ht);
50303
0
          zend_false_to_array_deprecated();
50304
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50305
0
            zend_array_destroy(ht);
50306
0
            goto assign_dim_error;
50307
0
          }
50308
0
        }
50309
42
        goto try_assign_dim_array;
50310
42
      }
50311
42
    } else {
50312
7
      zend_use_scalar_as_array();
50313
7
      dim = NULL;
50314
10
assign_dim_error:
50315
10
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50316
10
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50317
3
        ZVAL_NULL(EX_VAR(opline->result.var));
50318
3
      }
50319
10
    }
50320
49
  }
50321
1.48k
  if (IS_UNUSED != IS_UNUSED) {
50322
50323
0
  }
50324
50325
  /* assign_dim has two opcodes! */
50326
1.48k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
50327
1.48k
}
50328
50329
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50330
1.65k
{
50331
1.65k
  USE_OPLINE
50332
1.65k
  zval *object_ptr, *orig_object_ptr;
50333
1.65k
  zval *value;
50334
1.65k
  zval *variable_ptr;
50335
1.65k
  zval *dim;
50336
1.65k
  zend_refcounted *garbage = NULL;
50337
50338
1.65k
  SAVE_OPLINE();
50339
1.65k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50340
50341
1.65k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50342
1.65k
try_assign_dim_array:
50343
1.65k
    SEPARATE_ARRAY(object_ptr);
50344
1.65k
    if (IS_UNUSED == IS_UNUSED) {
50345
1.65k
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50346
1.65k
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50347
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
50348
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50349
0
          GC_ADDREF(ht);
50350
0
        }
50351
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50352
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50353
0
          zend_array_destroy(ht);
50354
0
          goto assign_dim_error;
50355
0
        }
50356
0
      }
50357
1.65k
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
50358
1.65k
        ZVAL_DEREF(value);
50359
1.65k
      }
50360
1.65k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50361
1.65k
      if (UNEXPECTED(value == NULL)) {
50362
0
        zend_cannot_add_element();
50363
0
        goto assign_dim_error;
50364
1.65k
      } else if (IS_VAR == IS_CV) {
50365
0
        if (Z_REFCOUNTED_P(value)) {
50366
0
          Z_ADDREF_P(value);
50367
0
        }
50368
1.65k
      } else if (IS_VAR == IS_VAR) {
50369
1.65k
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
50370
1.65k
        if (Z_ISREF_P(free_op_data)) {
50371
19
          if (Z_REFCOUNTED_P(value)) {
50372
5
            Z_ADDREF_P(value);
50373
5
          }
50374
19
          zval_ptr_dtor_nogc(free_op_data);
50375
19
        }
50376
1.65k
      } else if (IS_VAR == IS_CONST) {
50377
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50378
0
          Z_ADDREF_P(value);
50379
0
        }
50380
0
      }
50381
1.65k
    } else {
50382
0
      dim = NULL;
50383
0
      if (IS_UNUSED == IS_CONST) {
50384
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50385
0
      } else {
50386
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50387
0
      }
50388
0
      if (UNEXPECTED(variable_ptr == NULL)) {
50389
0
        goto assign_dim_error;
50390
0
      }
50391
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50392
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
50393
0
    }
50394
1.65k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50395
15
      ZVAL_COPY(EX_VAR(opline->result.var), value);
50396
15
    }
50397
1.65k
    if (garbage) {
50398
0
      GC_DTOR_NO_REF(garbage);
50399
0
    }
50400
1.65k
  } else {
50401
746
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
50402
683
      object_ptr = Z_REFVAL_P(object_ptr);
50403
683
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50404
558
        goto try_assign_dim_array;
50405
558
      }
50406
683
    }
50407
188
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50408
0
      zend_object *obj = Z_OBJ_P(object_ptr);
50409
50410
0
      GC_ADDREF(obj);
50411
0
      dim = NULL;
50412
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50413
0
        dim = ZVAL_UNDEFINED_OP2();
50414
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50415
0
        dim++;
50416
0
      }
50417
50418
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50419
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50420
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50421
0
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
50422
0
        ZVAL_DEREF(value);
50423
0
      }
50424
50425
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50426
50427
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50428
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50429
0
        zend_objects_store_del(obj);
50430
0
      }
50431
188
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50432
0
      if (IS_UNUSED == IS_UNUSED) {
50433
0
        zend_use_new_element_for_string();
50434
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50435
0
        UNDEF_RESULT();
50436
0
      } else {
50437
0
        dim = NULL;
50438
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50439
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50440
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50441
0
      }
50442
188
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50443
188
      if (Z_ISREF_P(orig_object_ptr)
50444
188
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50445
188
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50446
0
        dim = NULL;
50447
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50448
0
        UNDEF_RESULT();
50449
188
      } else {
50450
188
        HashTable *ht = zend_new_array(8);
50451
188
        uint8_t old_type = Z_TYPE_P(object_ptr);
50452
50453
188
        ZVAL_ARR(object_ptr, ht);
50454
188
        if (UNEXPECTED(old_type == IS_FALSE)) {
50455
5
          GC_ADDREF(ht);
50456
5
          zend_false_to_array_deprecated();
50457
5
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50458
0
            zend_array_destroy(ht);
50459
0
            goto assign_dim_error;
50460
0
          }
50461
5
        }
50462
188
        goto try_assign_dim_array;
50463
188
      }
50464
188
    } else {
50465
0
      zend_use_scalar_as_array();
50466
0
      dim = NULL;
50467
0
assign_dim_error:
50468
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50469
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50470
0
        ZVAL_NULL(EX_VAR(opline->result.var));
50471
0
      }
50472
0
    }
50473
188
  }
50474
1.65k
  if (IS_UNUSED != IS_UNUSED) {
50475
50476
0
  }
50477
50478
  /* assign_dim has two opcodes! */
50479
1.65k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
50480
1.65k
}
50481
50482
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50483
4.39k
{
50484
4.39k
  USE_OPLINE
50485
4.39k
  zval *object_ptr, *orig_object_ptr;
50486
4.39k
  zval *value;
50487
4.39k
  zval *variable_ptr;
50488
4.39k
  zval *dim;
50489
4.39k
  zend_refcounted *garbage = NULL;
50490
50491
4.39k
  SAVE_OPLINE();
50492
4.39k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50493
50494
4.39k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50495
4.36k
try_assign_dim_array:
50496
4.36k
    SEPARATE_ARRAY(object_ptr);
50497
4.36k
    if (IS_UNUSED == IS_UNUSED) {
50498
4.36k
      value = EX_VAR((opline+1)->op1.var);
50499
4.36k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50500
219
        HashTable *ht = Z_ARRVAL_P(object_ptr);
50501
219
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50502
219
          GC_ADDREF(ht);
50503
219
        }
50504
219
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50505
219
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50506
11
          zend_array_destroy(ht);
50507
11
          goto assign_dim_error;
50508
11
        }
50509
219
      }
50510
4.35k
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
50511
4.35k
        ZVAL_DEREF(value);
50512
4.35k
      }
50513
4.35k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50514
4.35k
      if (UNEXPECTED(value == NULL)) {
50515
0
        zend_cannot_add_element();
50516
0
        goto assign_dim_error;
50517
4.35k
      } else if (IS_CV == IS_CV) {
50518
4.35k
        if (Z_REFCOUNTED_P(value)) {
50519
2.02k
          Z_ADDREF_P(value);
50520
2.02k
        }
50521
4.35k
      } else if (IS_CV == IS_VAR) {
50522
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
50523
0
        if (Z_ISREF_P(free_op_data)) {
50524
0
          if (Z_REFCOUNTED_P(value)) {
50525
0
            Z_ADDREF_P(value);
50526
0
          }
50527
0
          zval_ptr_dtor_nogc(free_op_data);
50528
0
        }
50529
0
      } else if (IS_CV == IS_CONST) {
50530
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50531
0
          Z_ADDREF_P(value);
50532
0
        }
50533
0
      }
50534
4.35k
    } else {
50535
0
      dim = NULL;
50536
0
      if (IS_UNUSED == IS_CONST) {
50537
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50538
0
      } else {
50539
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50540
0
      }
50541
0
      if (UNEXPECTED(variable_ptr == NULL)) {
50542
0
        goto assign_dim_error;
50543
0
      }
50544
0
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
50545
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
50546
0
    }
50547
4.35k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50548
2
      ZVAL_COPY(EX_VAR(opline->result.var), value);
50549
2
    }
50550
4.35k
    if (garbage) {
50551
0
      GC_DTOR_NO_REF(garbage);
50552
0
    }
50553
4.35k
  } else {
50554
255
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
50555
181
      object_ptr = Z_REFVAL_P(object_ptr);
50556
181
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50557
170
        goto try_assign_dim_array;
50558
170
      }
50559
181
    }
50560
85
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50561
0
      zend_object *obj = Z_OBJ_P(object_ptr);
50562
50563
0
      GC_ADDREF(obj);
50564
0
      dim = NULL;
50565
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50566
0
        dim = ZVAL_UNDEFINED_OP2();
50567
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50568
0
        dim++;
50569
0
      }
50570
50571
0
      value = EX_VAR((opline+1)->op1.var);
50572
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50573
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50574
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
50575
0
        ZVAL_DEREF(value);
50576
0
      }
50577
50578
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50579
50580
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50581
0
        zend_objects_store_del(obj);
50582
0
      }
50583
85
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50584
0
      if (IS_UNUSED == IS_UNUSED) {
50585
0
        zend_use_new_element_for_string();
50586
50587
0
        UNDEF_RESULT();
50588
0
      } else {
50589
0
        dim = NULL;
50590
0
        value = EX_VAR((opline+1)->op1.var);
50591
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50592
50593
0
      }
50594
85
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50595
60
      if (Z_ISREF_P(orig_object_ptr)
50596
60
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50597
60
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50598
0
        dim = NULL;
50599
50600
0
        UNDEF_RESULT();
50601
60
      } else {
50602
60
        HashTable *ht = zend_new_array(8);
50603
60
        uint8_t old_type = Z_TYPE_P(object_ptr);
50604
50605
60
        ZVAL_ARR(object_ptr, ht);
50606
60
        if (UNEXPECTED(old_type == IS_FALSE)) {
50607
5
          GC_ADDREF(ht);
50608
5
          zend_false_to_array_deprecated();
50609
5
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50610
0
            zend_array_destroy(ht);
50611
0
            goto assign_dim_error;
50612
0
          }
50613
5
        }
50614
60
        goto try_assign_dim_array;
50615
60
      }
50616
60
    } else {
50617
25
      zend_use_scalar_as_array();
50618
25
      dim = NULL;
50619
36
assign_dim_error:
50620
50621
36
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50622
0
        ZVAL_NULL(EX_VAR(opline->result.var));
50623
0
      }
50624
36
    }
50625
85
  }
50626
4.39k
  if (IS_UNUSED != IS_UNUSED) {
50627
50628
0
  }
50629
50630
  /* assign_dim has two opcodes! */
50631
4.39k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
50632
4.39k
}
50633
50634
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50635
621
{
50636
621
  if (IS_CV == IS_UNUSED) {
50637
0
    SAVE_OPLINE();
50638
0
    zend_verify_missing_return_type(EX(func));
50639
0
    HANDLE_EXCEPTION();
50640
621
  } else {
50641
/* prevents "undefined variable opline" errors */
50642
621
#if 0 || (IS_CV != IS_UNUSED)
50643
621
    USE_OPLINE
50644
621
    zval *retval_ref, *retval_ptr;
50645
621
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
50646
621
    retval_ref = retval_ptr = EX_VAR(opline->op1.var);
50647
50648
621
    if (IS_CV == IS_CONST) {
50649
0
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
50650
0
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
50651
621
    } else if (IS_CV == IS_VAR) {
50652
0
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
50653
0
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
50654
0
      }
50655
0
      ZVAL_DEREF(retval_ptr);
50656
621
    } else if (IS_CV == IS_CV) {
50657
621
      ZVAL_DEREF(retval_ptr);
50658
621
    }
50659
50660
621
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
50661
277
      ZEND_VM_NEXT_OPCODE();
50662
277
    }
50663
50664
344
    if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
50665
41
      SAVE_OPLINE();
50666
41
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
50667
41
      if (UNEXPECTED(EG(exception))) {
50668
10
        HANDLE_EXCEPTION();
50669
10
      }
50670
31
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
50671
12
        ZEND_VM_NEXT_OPCODE();
50672
12
      }
50673
31
    }
50674
50675
322
    zend_reference *ref = NULL;
50676
322
    if (UNEXPECTED(retval_ref != retval_ptr)) {
50677
40
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
50678
18
        ref = Z_REF_P(retval_ref);
50679
22
      } else {
50680
        /* A cast might happen - unwrap the reference if this is a by-value return */
50681
22
        if (Z_REFCOUNT_P(retval_ref) == 1) {
50682
11
          ZVAL_UNREF(retval_ref);
50683
11
        } else {
50684
11
          Z_DELREF_P(retval_ref);
50685
11
          ZVAL_COPY(retval_ref, retval_ptr);
50686
11
        }
50687
22
        retval_ptr = retval_ref;
50688
22
      }
50689
40
    }
50690
50691
322
    SAVE_OPLINE();
50692
322
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
50693
64
      zend_verify_return_error(EX(func), retval_ptr);
50694
64
      HANDLE_EXCEPTION();
50695
64
    }
50696
258
    ZEND_VM_NEXT_OPCODE();
50697
258
#endif
50698
258
  }
50699
621
}
50700
50701
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50702
35.8k
{
50703
35.8k
  USE_OPLINE
50704
35.8k
  zval *varptr, *arg;
50705
50706
35.8k
  if (IS_UNUSED == IS_CONST) {
50707
0
    SAVE_OPLINE();
50708
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50709
0
    uint32_t arg_num;
50710
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50711
0
    if (UNEXPECTED(!arg)) {
50712
50713
0
      HANDLE_EXCEPTION();
50714
0
    }
50715
35.8k
  } else {
50716
35.8k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50717
35.8k
  }
50718
50719
35.8k
  varptr = EX_VAR(opline->op1.var);
50720
35.8k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50721
3.56k
    SAVE_OPLINE();
50722
3.56k
    ZVAL_UNDEFINED_OP1();
50723
3.56k
    ZVAL_NULL(arg);
50724
3.56k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50725
3.56k
  }
50726
50727
32.2k
  if (IS_CV == IS_CV) {
50728
32.2k
    ZVAL_COPY_DEREF(arg, varptr);
50729
32.2k
  } else /* if (IS_CV == IS_VAR) */ {
50730
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
50731
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
50732
50733
0
      varptr = Z_REFVAL_P(varptr);
50734
0
      ZVAL_COPY_VALUE(arg, varptr);
50735
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50736
0
        efree_size(ref, sizeof(zend_reference));
50737
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
50738
0
        Z_ADDREF_P(arg);
50739
0
      }
50740
0
    } else {
50741
0
      ZVAL_COPY_VALUE(arg, varptr);
50742
0
    }
50743
0
  }
50744
50745
32.2k
  ZEND_VM_NEXT_OPCODE();
50746
32.2k
}
50747
50748
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50749
4.98k
{
50750
4.98k
  USE_OPLINE
50751
4.98k
  zval *varptr, *arg;
50752
50753
4.98k
  SAVE_OPLINE();
50754
4.98k
  if (IS_UNUSED == IS_CONST) {
50755
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50756
0
    uint32_t arg_num;
50757
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50758
0
    if (UNEXPECTED(!arg)) {
50759
50760
0
      HANDLE_EXCEPTION();
50761
0
    }
50762
4.98k
  } else {
50763
4.98k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50764
4.98k
  }
50765
50766
4.98k
  varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50767
4.98k
  if (Z_ISREF_P(varptr)) {
50768
3.30k
    Z_ADDREF_P(varptr);
50769
3.30k
  } else {
50770
1.67k
    ZVAL_MAKE_REF_EX(varptr, 2);
50771
1.67k
  }
50772
4.98k
  ZVAL_REF(arg, Z_REF_P(varptr));
50773
50774
4.98k
  ZEND_VM_NEXT_OPCODE();
50775
4.98k
}
50776
50777
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50778
5
{
50779
5
  USE_OPLINE
50780
5
  zval *varptr, *arg;
50781
5
  uint32_t arg_num;
50782
50783
5
  if (IS_UNUSED == IS_CONST) {
50784
0
    SAVE_OPLINE();
50785
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50786
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50787
0
    if (UNEXPECTED(!arg)) {
50788
50789
0
      HANDLE_EXCEPTION();
50790
0
    }
50791
5
  } else {
50792
5
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50793
5
    arg_num = opline->op2.num;
50794
5
  }
50795
50796
5
  if (EXPECTED(0)) {
50797
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50798
0
      goto send_var_by_ref;
50799
0
    }
50800
5
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50801
5
send_var_by_ref:
50802
5
    varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50803
5
    if (Z_ISREF_P(varptr)) {
50804
0
      Z_ADDREF_P(varptr);
50805
5
    } else {
50806
5
      ZVAL_MAKE_REF_EX(varptr, 2);
50807
5
    }
50808
5
    ZVAL_REF(arg, Z_REF_P(varptr));
50809
50810
5
    ZEND_VM_NEXT_OPCODE();
50811
5
  }
50812
50813
0
  varptr = EX_VAR(opline->op1.var);
50814
0
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50815
0
    SAVE_OPLINE();
50816
0
    ZVAL_UNDEFINED_OP1();
50817
0
    ZVAL_NULL(arg);
50818
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50819
0
  }
50820
50821
0
  if (IS_CV == IS_CV) {
50822
0
    ZVAL_COPY_DEREF(arg, varptr);
50823
0
  } else /* if (IS_CV == IS_VAR) */ {
50824
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
50825
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
50826
50827
0
      varptr = Z_REFVAL_P(varptr);
50828
0
      ZVAL_COPY_VALUE(arg, varptr);
50829
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50830
0
        efree_size(ref, sizeof(zend_reference));
50831
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
50832
0
        Z_ADDREF_P(arg);
50833
0
      }
50834
0
    } else {
50835
0
      ZVAL_COPY_VALUE(arg, varptr);
50836
0
    }
50837
0
  }
50838
50839
0
  ZEND_VM_NEXT_OPCODE();
50840
0
}
50841
50842
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50843
1.23M
{
50844
1.23M
  USE_OPLINE
50845
1.23M
  zval *varptr, *arg;
50846
1.23M
  uint32_t arg_num;
50847
50848
1.23M
  if (IS_UNUSED == IS_CONST) {
50849
0
    SAVE_OPLINE();
50850
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50851
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50852
0
    if (UNEXPECTED(!arg)) {
50853
50854
0
      HANDLE_EXCEPTION();
50855
0
    }
50856
1.23M
  } else {
50857
1.23M
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50858
1.23M
    arg_num = opline->op2.num;
50859
1.23M
  }
50860
50861
1.23M
  if (EXPECTED(1)) {
50862
1.23M
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50863
387
      goto send_var_by_ref;
50864
387
    }
50865
1.23M
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50866
387
send_var_by_ref:
50867
387
    varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50868
387
    if (Z_ISREF_P(varptr)) {
50869
179
      Z_ADDREF_P(varptr);
50870
208
    } else {
50871
208
      ZVAL_MAKE_REF_EX(varptr, 2);
50872
208
    }
50873
387
    ZVAL_REF(arg, Z_REF_P(varptr));
50874
50875
387
    ZEND_VM_NEXT_OPCODE();
50876
387
  }
50877
50878
1.23M
  varptr = EX_VAR(opline->op1.var);
50879
1.23M
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50880
577k
    SAVE_OPLINE();
50881
577k
    ZVAL_UNDEFINED_OP1();
50882
577k
    ZVAL_NULL(arg);
50883
577k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50884
577k
  }
50885
50886
653k
  if (IS_CV == IS_CV) {
50887
653k
    ZVAL_COPY_DEREF(arg, varptr);
50888
653k
  } else /* if (IS_CV == IS_VAR) */ {
50889
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
50890
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
50891
50892
0
      varptr = Z_REFVAL_P(varptr);
50893
0
      ZVAL_COPY_VALUE(arg, varptr);
50894
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50895
0
        efree_size(ref, sizeof(zend_reference));
50896
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
50897
0
        Z_ADDREF_P(arg);
50898
0
      }
50899
0
    } else {
50900
0
      ZVAL_COPY_VALUE(arg, varptr);
50901
0
    }
50902
0
  }
50903
50904
653k
  ZEND_VM_NEXT_OPCODE();
50905
653k
}
50906
50907
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50908
3.13k
{
50909
3.13k
  USE_OPLINE
50910
3.13k
  zval *expr_ptr, new_expr;
50911
50912
3.13k
  SAVE_OPLINE();
50913
3.13k
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
50914
3.13k
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
50915
317
    expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50916
317
    if (Z_ISREF_P(expr_ptr)) {
50917
110
      Z_ADDREF_P(expr_ptr);
50918
207
    } else {
50919
207
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
50920
207
    }
50921
50922
2.81k
  } else {
50923
2.81k
    expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50924
2.81k
    if (IS_CV == IS_TMP_VAR) {
50925
      /* pass */
50926
2.81k
    } else if (IS_CV == IS_CONST) {
50927
0
      Z_TRY_ADDREF_P(expr_ptr);
50928
2.81k
    } else if (IS_CV == IS_CV) {
50929
2.81k
      ZVAL_DEREF(expr_ptr);
50930
2.81k
      Z_TRY_ADDREF_P(expr_ptr);
50931
2.81k
    } else /* if (IS_CV == IS_VAR) */ {
50932
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
50933
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
50934
50935
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
50936
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50937
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
50938
0
          expr_ptr = &new_expr;
50939
0
          efree_size(ref, sizeof(zend_reference));
50940
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
50941
0
          Z_ADDREF_P(expr_ptr);
50942
0
        }
50943
0
      }
50944
0
    }
50945
2.81k
  }
50946
50947
3.13k
  if (IS_UNUSED != IS_UNUSED) {
50948
0
    zval *offset = NULL;
50949
0
    zend_string *str;
50950
0
    zend_ulong hval;
50951
50952
0
add_again:
50953
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
50954
0
      str = Z_STR_P(offset);
50955
0
      if (IS_UNUSED != IS_CONST) {
50956
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
50957
0
          goto num_index;
50958
0
        }
50959
0
      }
50960
0
str_index:
50961
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
50962
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
50963
0
      hval = Z_LVAL_P(offset);
50964
0
num_index:
50965
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
50966
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
50967
0
      offset = Z_REFVAL_P(offset);
50968
0
      goto add_again;
50969
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
50970
0
      str = ZSTR_EMPTY_ALLOC();
50971
0
      goto str_index;
50972
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
50973
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
50974
0
      goto num_index;
50975
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
50976
0
      hval = 0;
50977
0
      goto num_index;
50978
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
50979
0
      hval = 1;
50980
0
      goto num_index;
50981
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
50982
0
      zend_use_resource_as_offset(offset);
50983
0
      hval = Z_RES_HANDLE_P(offset);
50984
0
      goto num_index;
50985
0
    } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
50986
0
      ZVAL_UNDEFINED_OP2();
50987
0
      str = ZSTR_EMPTY_ALLOC();
50988
0
      goto str_index;
50989
0
    } else {
50990
0
      zend_illegal_array_offset_access(offset);
50991
0
      zval_ptr_dtor_nogc(expr_ptr);
50992
0
    }
50993
50994
3.13k
  } else {
50995
3.13k
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
50996
0
      zend_cannot_add_element();
50997
0
      zval_ptr_dtor_nogc(expr_ptr);
50998
0
    }
50999
3.13k
  }
51000
3.13k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51001
3.13k
}
51002
51003
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51004
2.26k
{
51005
2.26k
  zval *array;
51006
2.26k
  uint32_t size;
51007
2.26k
  USE_OPLINE
51008
51009
2.26k
  SAVE_OPLINE();
51010
2.26k
  array = EX_VAR(opline->result.var);
51011
2.26k
  if (IS_CV != IS_UNUSED) {
51012
2.26k
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
51013
2.26k
    ZVAL_ARR(array, zend_new_array(size));
51014
    /* Explicitly initialize array as not-packed if flag is set */
51015
2.26k
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
51016
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
51017
0
    }
51018
2.26k
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51019
2.26k
  } else {
51020
0
    ZVAL_ARR(array, zend_new_array(0));
51021
0
    ZEND_VM_NEXT_OPCODE();
51022
0
  }
51023
2.26k
}
51024
51025
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51026
5.97k
{
51027
5.97k
  USE_OPLINE
51028
5.97k
  zval *var = EX_VAR(opline->op1.var);
51029
51030
5.97k
  if (Z_REFCOUNTED_P(var)) {
51031
4.36k
    zend_refcounted *garbage = Z_COUNTED_P(var);
51032
51033
4.36k
    ZVAL_UNDEF(var);
51034
4.36k
    SAVE_OPLINE();
51035
4.36k
    GC_DTOR(garbage);
51036
4.36k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51037
4.36k
  } else {
51038
1.61k
    ZVAL_UNDEF(var);
51039
1.61k
  }
51040
1.61k
  ZEND_VM_NEXT_OPCODE();
51041
1.61k
}
51042
51043
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51044
113
{
51045
113
  USE_OPLINE
51046
113
  zval *varname;
51047
113
  zend_string *name, *tmp_name;
51048
113
  HashTable *target_symbol_table;
51049
51050
113
  SAVE_OPLINE();
51051
51052
113
  varname = EX_VAR(opline->op1.var);
51053
51054
113
  if (IS_CV == IS_CONST) {
51055
0
    name = Z_STR_P(varname);
51056
113
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
51057
47
    name = Z_STR_P(varname);
51058
47
    tmp_name = NULL;
51059
66
  } else {
51060
66
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
51061
49
      varname = ZVAL_UNDEFINED_OP1();
51062
49
    }
51063
66
    name = zval_try_get_tmp_string(varname, &tmp_name);
51064
66
    if (UNEXPECTED(!name)) {
51065
51066
8
      HANDLE_EXCEPTION();
51067
8
    }
51068
66
  }
51069
51070
105
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
51071
105
  zend_hash_del_ind(target_symbol_table, name);
51072
51073
105
  if (IS_CV != IS_CONST) {
51074
105
    zend_tmp_string_release(tmp_name);
51075
105
  }
51076
51077
105
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51078
105
}
51079
51080
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
51081
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51082
80
{
51083
80
  USE_OPLINE
51084
80
  zval *value;
51085
51086
80
  value = EX_VAR(opline->op1.var);
51087
80
  if (!(0)) {
51088
80
    if (Z_TYPE_P(value) > IS_NULL &&
51089
80
        (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
51090
41
      ZEND_VM_SMART_BRANCH_TRUE();
51091
41
    } else {
51092
39
      ZEND_VM_SMART_BRANCH_FALSE();
51093
39
    }
51094
80
  } else {
51095
0
    bool result;
51096
51097
0
    SAVE_OPLINE();
51098
0
    result = !i_zend_is_true(value);
51099
0
    ZEND_VM_SMART_BRANCH(result, 1);
51100
0
  }
51101
80
}
51102
51103
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51104
3
{
51105
3
  USE_OPLINE
51106
3
  zval *value;
51107
51108
3
  value = EX_VAR(opline->op1.var);
51109
3
  if (!(1)) {
51110
0
    if (Z_TYPE_P(value) > IS_NULL &&
51111
0
        (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
51112
0
      ZEND_VM_SMART_BRANCH_TRUE();
51113
0
    } else {
51114
0
      ZEND_VM_SMART_BRANCH_FALSE();
51115
0
    }
51116
3
  } else {
51117
3
    bool result;
51118
51119
3
    SAVE_OPLINE();
51120
3
    result = !i_zend_is_true(value);
51121
3
    ZEND_VM_SMART_BRANCH(result, 1);
51122
3
  }
51123
3
}
51124
51125
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51126
74
{
51127
74
  USE_OPLINE
51128
74
  zval *value;
51129
74
  bool result;
51130
74
  zval *varname;
51131
74
  zend_string *name, *tmp_name;
51132
74
  HashTable *target_symbol_table;
51133
51134
74
  SAVE_OPLINE();
51135
74
  varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
51136
74
  if (IS_CV == IS_CONST) {
51137
0
    name = Z_STR_P(varname);
51138
74
  } else {
51139
74
    name = zval_get_tmp_string(varname, &tmp_name);
51140
74
  }
51141
51142
74
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
51143
74
  value = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
51144
51145
74
  if (IS_CV != IS_CONST) {
51146
74
    zend_tmp_string_release(tmp_name);
51147
74
  }
51148
51149
74
  if (!value) {
51150
24
    result = (opline->extended_value & ZEND_ISEMPTY);
51151
50
  } else {
51152
50
    if (Z_TYPE_P(value) == IS_INDIRECT) {
51153
27
      value = Z_INDIRECT_P(value);
51154
27
    }
51155
50
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
51156
50
      if (Z_ISREF_P(value)) {
51157
0
        value = Z_REFVAL_P(value);
51158
0
      }
51159
50
      result = Z_TYPE_P(value) > IS_NULL;
51160
50
    } else {
51161
0
      result = !i_zend_is_true(value);
51162
0
    }
51163
50
  }
51164
51165
74
  ZEND_VM_SMART_BRANCH(result, true);
51166
74
}
51167
51168
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
51169
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51170
82
{
51171
82
  USE_OPLINE
51172
82
  zval *expr;
51173
82
  bool result;
51174
51175
82
  SAVE_OPLINE();
51176
82
  expr = EX_VAR(opline->op1.var);
51177
51178
82
try_instanceof:
51179
82
  if (Z_TYPE_P(expr) == IS_OBJECT) {
51180
80
    zend_class_entry *ce;
51181
51182
80
    if (IS_UNUSED == IS_CONST) {
51183
0
      ce = CACHED_PTR(opline->extended_value);
51184
0
      if (UNEXPECTED(ce == NULL)) {
51185
0
        ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD);
51186
0
        if (EXPECTED(ce)) {
51187
0
          CACHE_PTR(opline->extended_value, ce);
51188
0
        }
51189
0
      }
51190
80
    } else if (IS_UNUSED == IS_UNUSED) {
51191
80
      ce = zend_fetch_class(NULL, opline->op2.num);
51192
80
      if (UNEXPECTED(ce == NULL)) {
51193
51194
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
51195
0
        HANDLE_EXCEPTION();
51196
0
      }
51197
80
    } else {
51198
0
      ce = Z_CE_P(EX_VAR(opline->op2.var));
51199
0
    }
51200
80
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
51201
80
  } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
51202
0
    expr = Z_REFVAL_P(expr);
51203
0
    goto try_instanceof;
51204
2
  } else {
51205
2
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
51206
2
      ZVAL_UNDEFINED_OP1();
51207
2
    }
51208
2
    result = 0;
51209
2
  }
51210
51211
82
  ZEND_VM_SMART_BRANCH(result, 1);
51212
82
}
51213
51214
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51215
1.33k
{
51216
1.33k
  USE_OPLINE
51217
51218
1.33k
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
51219
51220
1.33k
  SAVE_OPLINE();
51221
1.33k
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
51222
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51223
0
  }
51224
51225
  /* Destroy the previously yielded value */
51226
1.33k
  zval_ptr_dtor(&generator->value);
51227
51228
  /* Destroy the previously yielded key */
51229
1.33k
  zval_ptr_dtor(&generator->key);
51230
51231
  /* Set the new yielded value */
51232
1.33k
  if (IS_CV != IS_UNUSED) {
51233
1.33k
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
51234
      /* Constants and temporary variables aren't yieldable by reference,
51235
       * but we still allow them with a notice. */
51236
37
      if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
51237
0
        zval *value;
51238
51239
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
51240
51241
0
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51242
0
        ZVAL_COPY_VALUE(&generator->value, value);
51243
0
        if (IS_CV == IS_CONST) {
51244
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
51245
0
            Z_ADDREF(generator->value);
51246
0
          }
51247
0
        }
51248
37
      } else {
51249
37
        zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
51250
51251
        /* If a function call result is yielded and the function did
51252
         * not return by reference we throw a notice. */
51253
37
        do {
51254
37
          if (IS_CV == IS_VAR) {
51255
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
51256
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
51257
0
             && !Z_ISREF_P(value_ptr)) {
51258
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
51259
0
              ZVAL_COPY(&generator->value, value_ptr);
51260
0
              break;
51261
0
            }
51262
0
          }
51263
37
          if (Z_ISREF_P(value_ptr)) {
51264
17
            Z_ADDREF_P(value_ptr);
51265
20
          } else {
51266
20
            ZVAL_MAKE_REF_EX(value_ptr, 2);
51267
20
          }
51268
37
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
51269
37
        } while (0);
51270
51271
37
      }
51272
1.29k
    } else {
51273
1.29k
      zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51274
51275
      /* Consts, temporary variables and references need copying */
51276
1.29k
      if (IS_CV == IS_CONST) {
51277
0
        ZVAL_COPY_VALUE(&generator->value, value);
51278
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
51279
0
          Z_ADDREF(generator->value);
51280
0
        }
51281
1.29k
      } else if (IS_CV == IS_TMP_VAR) {
51282
0
        ZVAL_COPY_VALUE(&generator->value, value);
51283
1.29k
      } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
51284
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
51285
51286
1.29k
      } else {
51287
1.29k
        ZVAL_COPY_VALUE(&generator->value, value);
51288
1.29k
        if (IS_CV == IS_CV) {
51289
1.29k
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
51290
1.29k
        }
51291
1.29k
      }
51292
1.29k
    }
51293
1.33k
  } else {
51294
    /* If no value was specified yield null */
51295
0
    ZVAL_NULL(&generator->value);
51296
0
  }
51297
51298
  /* Set the new yielded key */
51299
1.33k
  if (IS_UNUSED != IS_UNUSED) {
51300
0
    zval *key = NULL;
51301
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
51302
0
      key = Z_REFVAL_P(key);
51303
0
    }
51304
0
    ZVAL_COPY(&generator->key, key);
51305
51306
0
    if (Z_TYPE(generator->key) == IS_LONG
51307
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
51308
0
    ) {
51309
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
51310
0
    }
51311
1.33k
  } else {
51312
    /* If no key was specified we use auto-increment keys */
51313
1.33k
    generator->largest_used_integer_key++;
51314
1.33k
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
51315
1.33k
  }
51316
51317
1.33k
  if (RETURN_VALUE_USED(opline)) {
51318
    /* If the return value of yield is used set the send
51319
     * target and initialize it to NULL */
51320
0
    generator->send_target = EX_VAR(opline->result.var);
51321
0
    ZVAL_NULL(generator->send_target);
51322
1.33k
  } else {
51323
1.33k
    generator->send_target = NULL;
51324
1.33k
  }
51325
51326
  /* The GOTO VM uses a local opline variable. We need to set the opline
51327
   * variable in execute_data so we don't resume at an old position. */
51328
1.33k
  SAVE_OPLINE();
51329
51330
1.33k
  ZEND_VM_RETURN();
51331
1.33k
}
51332
51333
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51334
9
{
51335
9
  USE_OPLINE
51336
9
  zval *op1 = EX_VAR(opline->op1.var);
51337
51338
9
  if (UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
51339
9
    SAVE_OPLINE();
51340
9
    ZVAL_UNDEFINED_OP1();
51341
9
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51342
9
  }
51343
0
  ZEND_VM_NEXT_OPCODE();
51344
0
}
51345
51346
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51347
246
{
51348
246
  USE_OPLINE
51349
246
  zval *op1 = EX_VAR(opline->op1.var);
51350
51351
246
  if (IS_CV == IS_CV) {
51352
246
    if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51353
17
      ZVAL_NEW_EMPTY_REF(op1);
51354
17
      Z_SET_REFCOUNT_P(op1, 2);
51355
17
      ZVAL_NULL(Z_REFVAL_P(op1));
51356
17
      ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51357
229
    } else {
51358
229
      if (Z_ISREF_P(op1)) {
51359
169
        Z_ADDREF_P(op1);
51360
169
      } else {
51361
60
        ZVAL_MAKE_REF_EX(op1, 2);
51362
60
      }
51363
229
      ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51364
229
    }
51365
246
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
51366
0
    op1 = Z_INDIRECT_P(op1);
51367
0
    if (EXPECTED(!Z_ISREF_P(op1))) {
51368
0
      ZVAL_MAKE_REF_EX(op1, 2);
51369
0
    } else {
51370
0
      GC_ADDREF(Z_REF_P(op1));
51371
0
    }
51372
0
    ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51373
0
  } else {
51374
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
51375
0
  }
51376
246
  ZEND_VM_NEXT_OPCODE();
51377
246
}
51378
51379
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51380
1.00k
{
51381
1.00k
  USE_OPLINE
51382
1.00k
  zval *op1;
51383
1.00k
  zend_long count;
51384
51385
1.00k
  SAVE_OPLINE();
51386
1.00k
  op1 = EX_VAR(opline->op1.var);
51387
51388
1.48k
  while (1) {
51389
1.48k
    if (Z_TYPE_P(op1) == IS_ARRAY) {
51390
909
      count = zend_hash_num_elements(Z_ARRVAL_P(op1));
51391
909
      break;
51392
909
    } else if (Z_TYPE_P(op1) == IS_OBJECT) {
51393
86
      zend_object *zobj = Z_OBJ_P(op1);
51394
51395
      /* first, we check if the handler is defined */
51396
86
      if (zobj->handlers->count_elements) {
51397
81
        if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
51398
81
          break;
51399
81
        }
51400
0
        if (UNEXPECTED(EG(exception))) {
51401
0
          count = 0;
51402
0
          break;
51403
0
        }
51404
0
      }
51405
51406
      /* if not and the object implements Countable we call its count() method */
51407
5
      if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
51408
0
        zval retval;
51409
51410
0
        zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
51411
0
        zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
51412
0
        count = zval_get_long(&retval);
51413
0
        zval_ptr_dtor(&retval);
51414
0
        break;
51415
0
      }
51416
51417
      /* If There's no handler and it doesn't implement Countable then emit a TypeError */
51418
492
    } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
51419
482
      op1 = Z_REFVAL_P(op1);
51420
482
      continue;
51421
482
    } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51422
8
      ZVAL_UNDEFINED_OP1();
51423
8
    }
51424
15
    count = 0;
51425
15
    zend_type_error("%s(): Argument #1 ($value) must be of type Countable|array, %s given", opline->extended_value ? "sizeof" : "count", zend_zval_value_name(op1));
51426
15
    break;
51427
1.48k
  }
51428
51429
1.00k
  ZVAL_LONG(EX_VAR(opline->result.var), count);
51430
51431
1.00k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51432
1.00k
}
51433
51434
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51435
318
{
51436
318
  USE_OPLINE
51437
318
  zend_array *ht = Z_ARRVAL_P(EX_VAR(opline->op1.var));
51438
318
  ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
51439
318
  if (IS_CV & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
51440
0
    SAVE_OPLINE();
51441
0
    zend_array_destroy(ht);
51442
0
    if (EG(exception)) {
51443
0
      HANDLE_EXCEPTION();
51444
0
    }
51445
0
  }
51446
318
  ZEND_VM_NEXT_OPCODE();
51447
318
}
51448
51449
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51450
808
{
51451
808
  USE_OPLINE
51452
51453
808
  if (IS_CV == IS_UNUSED) {
51454
0
    SAVE_OPLINE();
51455
0
    if (UNEXPECTED(!EX(func)->common.scope)) {
51456
0
      zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
51457
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
51458
0
      HANDLE_EXCEPTION();
51459
0
    } else {
51460
0
      zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
51461
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
51462
0
      if (UNEXPECTED(EG(exception))) {
51463
0
        HANDLE_EXCEPTION();
51464
0
      }
51465
0
      ZEND_VM_NEXT_OPCODE();
51466
0
    }
51467
808
  } else {
51468
808
    zval *op1;
51469
51470
808
    SAVE_OPLINE();
51471
808
    op1 = EX_VAR(opline->op1.var);
51472
808
    while (1) {
51473
808
      if (Z_TYPE_P(op1) == IS_OBJECT) {
51474
795
        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
51475
795
      } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
51476
0
        op1 = Z_REFVAL_P(op1);
51477
0
        continue;
51478
13
      } else {
51479
13
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51480
10
          ZVAL_UNDEFINED_OP1();
51481
10
        }
51482
13
        zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
51483
13
        ZVAL_UNDEF(EX_VAR(opline->result.var));
51484
13
      }
51485
808
      break;
51486
808
    }
51487
51488
808
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51489
808
  }
51490
808
}
51491
51492
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51493
14
{
51494
14
  USE_OPLINE
51495
14
  zval *op1;
51496
14
  zend_string *type;
51497
51498
14
  SAVE_OPLINE();
51499
14
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51500
14
  type = zend_zval_get_legacy_type(op1);
51501
14
  if (EXPECTED(type)) {
51502
14
    ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
51503
14
  } else {
51504
0
    ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
51505
0
  }
51506
51507
14
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51508
14
}
51509
51510
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51511
2.88k
{
51512
2.88k
  USE_OPLINE
51513
2.88k
  zval *varptr, *arg;
51514
2.88k
  uint32_t arg_num = opline->op2.num;
51515
51516
2.88k
  if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
51517
13
    ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51518
13
  }
51519
51520
2.87k
  varptr = EX_VAR(opline->op1.var);
51521
2.87k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
51522
51523
2.87k
  if (IS_CV == IS_CV) {
51524
2.87k
    ZVAL_COPY(arg, varptr);
51525
2.87k
  } else /* if (IS_CV == IS_VAR) */ {
51526
0
    ZVAL_COPY_VALUE(arg, varptr);
51527
0
  }
51528
51529
2.87k
  ZEND_VM_NEXT_OPCODE();
51530
2.87k
}
51531
51532
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51533
157
{
51534
157
  USE_OPLINE
51535
157
  zval *op1, *op2;
51536
51537
157
  SAVE_OPLINE();
51538
157
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51539
157
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51540
157
  div_function(EX_VAR(opline->result.var), op1, op2);
51541
51542
51543
157
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51544
157
}
51545
51546
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51547
2
{
51548
2
  USE_OPLINE
51549
2
  zval *op1, *op2;
51550
51551
2
  SAVE_OPLINE();
51552
2
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51553
2
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51554
2
  pow_function(EX_VAR(opline->result.var), op1, op2);
51555
51556
51557
2
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51558
2
}
51559
51560
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51561
1.89k
{
51562
1.89k
  USE_OPLINE
51563
1.89k
  zval *op1, *op2;
51564
51565
1.89k
  op1 = EX_VAR(opline->op1.var);
51566
1.89k
  op2 = EX_VAR(opline->op2.var);
51567
51568
1.89k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
51569
1.89k
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
51570
822
    zend_string *op1_str = Z_STR_P(op1);
51571
822
    zend_string *op2_str = Z_STR_P(op2);
51572
822
    zend_string *str;
51573
822
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
51574
51575
822
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
51576
6
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
51577
6
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
51578
6
      } else {
51579
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
51580
0
      }
51581
6
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51582
0
        zend_string_release_ex(op1_str, 0);
51583
0
      }
51584
816
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
51585
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
51586
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
51587
0
      } else {
51588
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
51589
0
      }
51590
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51591
0
        zend_string_release_ex(op2_str, 0);
51592
0
      }
51593
816
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
51594
816
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
51595
0
      size_t len = ZSTR_LEN(op1_str);
51596
51597
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
51598
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
51599
0
      }
51600
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
51601
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
51602
0
      GC_ADD_FLAGS(str, flags);
51603
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
51604
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51605
0
        zend_string_release_ex(op2_str, 0);
51606
0
      }
51607
816
    } else {
51608
816
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
51609
816
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
51610
816
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
51611
816
      GC_ADD_FLAGS(str, flags);
51612
816
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
51613
816
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51614
0
        zend_string_release_ex(op1_str, 0);
51615
0
      }
51616
816
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51617
0
        zend_string_release_ex(op2_str, 0);
51618
0
      }
51619
816
    }
51620
822
    ZEND_VM_NEXT_OPCODE();
51621
1.06k
  } else {
51622
1.06k
    SAVE_OPLINE();
51623
51624
1.06k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51625
278
      op1 = ZVAL_UNDEFINED_OP1();
51626
278
    }
51627
1.06k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
51628
682
      op2 = ZVAL_UNDEFINED_OP2();
51629
682
    }
51630
1.06k
    concat_function(EX_VAR(opline->result.var), op1, op2);
51631
51632
51633
1.06k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51634
1.06k
  }
51635
1.89k
}
51636
51637
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51638
262
{
51639
262
  USE_OPLINE
51640
262
  zval *op1, *op2;
51641
262
  bool result;
51642
51643
262
  SAVE_OPLINE();
51644
262
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51645
262
  op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51646
262
  result = fast_is_identical_function(op1, op2);
51647
51648
51649
262
  ZEND_VM_SMART_BRANCH(result, 1);
51650
262
}
51651
51652
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51653
999
{
51654
999
  USE_OPLINE
51655
999
  zval *op1, *op2;
51656
999
  bool result;
51657
51658
999
  SAVE_OPLINE();
51659
999
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51660
999
  op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51661
999
  result = fast_is_not_identical_function(op1, op2);
51662
51663
51664
999
  ZEND_VM_SMART_BRANCH(result, 1);
51665
999
}
51666
51667
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51668
4.03k
{
51669
4.03k
  USE_OPLINE
51670
4.03k
  zval *op1, *op2;
51671
4.03k
  double d1, d2;
51672
51673
4.03k
  op1 = EX_VAR(opline->op1.var);
51674
4.03k
  op2 = EX_VAR(opline->op2.var);
51675
4.03k
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51676
    /* pass */
51677
4.03k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51678
3.00k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51679
1.48k
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51680
1.04k
is_equal_true:
51681
1.04k
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
51682
1.04k
      } else {
51683
1.10k
is_equal_false:
51684
1.10k
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
51685
1.10k
      }
51686
1.51k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51687
72
      d1 = (double)Z_LVAL_P(op1);
51688
72
      d2 = Z_DVAL_P(op2);
51689
72
      goto is_equal_double;
51690
72
    }
51691
3.00k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51692
600
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51693
498
      d1 = Z_DVAL_P(op1);
51694
498
      d2 = Z_DVAL_P(op2);
51695
584
is_equal_double:
51696
584
      if (d1 == d2) {
51697
110
        goto is_equal_true;
51698
474
      } else {
51699
474
        goto is_equal_false;
51700
474
      }
51701
584
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51702
14
      d1 = Z_DVAL_P(op1);
51703
14
      d2 = (double)Z_LVAL_P(op2);
51704
14
      goto is_equal_double;
51705
14
    }
51706
600
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51707
74
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51708
74
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51709
74
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51710
0
        zval_ptr_dtor_str(op1);
51711
0
      }
51712
74
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51713
0
        zval_ptr_dtor_str(op2);
51714
0
      }
51715
74
      if (result) {
51716
64
        goto is_equal_true;
51717
64
      } else {
51718
10
        goto is_equal_false;
51719
10
      }
51720
74
    }
51721
74
  }
51722
4.03k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51723
4.03k
}
51724
51725
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51726
49
{
51727
49
  USE_OPLINE
51728
49
  zval *op1, *op2;
51729
49
  double d1, d2;
51730
51731
49
  op1 = EX_VAR(opline->op1.var);
51732
49
  op2 = EX_VAR(opline->op2.var);
51733
49
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51734
    /* pass */
51735
49
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51736
11
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51737
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51738
10
is_equal_true:
51739
10
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
51740
10
      } else {
51741
39
is_equal_false:
51742
39
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
51743
39
      }
51744
11
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51745
11
      d1 = (double)Z_LVAL_P(op1);
51746
11
      d2 = Z_DVAL_P(op2);
51747
11
      goto is_equal_double;
51748
11
    }
51749
38
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51750
18
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51751
18
      d1 = Z_DVAL_P(op1);
51752
18
      d2 = Z_DVAL_P(op2);
51753
29
is_equal_double:
51754
29
      if (d1 == d2) {
51755
0
        goto is_equal_true;
51756
29
      } else {
51757
29
        goto is_equal_false;
51758
29
      }
51759
29
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51760
0
      d1 = Z_DVAL_P(op1);
51761
0
      d2 = (double)Z_LVAL_P(op2);
51762
0
      goto is_equal_double;
51763
0
    }
51764
20
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51765
20
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51766
20
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51767
20
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51768
0
        zval_ptr_dtor_str(op1);
51769
0
      }
51770
20
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51771
0
        zval_ptr_dtor_str(op2);
51772
0
      }
51773
20
      if (result) {
51774
10
        goto is_equal_true;
51775
10
      } else {
51776
10
        goto is_equal_false;
51777
10
      }
51778
20
    }
51779
20
  }
51780
49
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51781
49
}
51782
51783
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51784
161
{
51785
161
  USE_OPLINE
51786
161
  zval *op1, *op2;
51787
161
  double d1, d2;
51788
51789
161
  op1 = EX_VAR(opline->op1.var);
51790
161
  op2 = EX_VAR(opline->op2.var);
51791
161
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51792
    /* pass */
51793
161
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51794
45
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51795
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51796
0
is_equal_true:
51797
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
51798
0
      } else {
51799
22
is_equal_false:
51800
22
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
51801
22
      }
51802
45
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51803
9
      d1 = (double)Z_LVAL_P(op1);
51804
9
      d2 = Z_DVAL_P(op2);
51805
9
      goto is_equal_double;
51806
9
    }
51807
116
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51808
13
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51809
13
      d1 = Z_DVAL_P(op1);
51810
13
      d2 = Z_DVAL_P(op2);
51811
22
is_equal_double:
51812
22
      if (d1 == d2) {
51813
0
        goto is_equal_true;
51814
22
      } else {
51815
22
        goto is_equal_false;
51816
22
      }
51817
22
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51818
0
      d1 = Z_DVAL_P(op1);
51819
0
      d2 = (double)Z_LVAL_P(op2);
51820
0
      goto is_equal_double;
51821
0
    }
51822
103
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51823
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51824
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51825
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51826
0
        zval_ptr_dtor_str(op1);
51827
0
      }
51828
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51829
0
        zval_ptr_dtor_str(op2);
51830
0
      }
51831
0
      if (result) {
51832
0
        goto is_equal_true;
51833
0
      } else {
51834
0
        goto is_equal_false;
51835
0
      }
51836
0
    }
51837
0
  }
51838
161
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51839
161
}
51840
51841
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51842
4.76k
{
51843
4.76k
  USE_OPLINE
51844
4.76k
  zval *op1, *op2;
51845
4.76k
  double d1, d2;
51846
51847
4.76k
  op1 = EX_VAR(opline->op1.var);
51848
4.76k
  op2 = EX_VAR(opline->op2.var);
51849
4.76k
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51850
    /* pass */
51851
4.76k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51852
512
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51853
121
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51854
134
is_not_equal_true:
51855
134
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
51856
134
      } else {
51857
167
is_not_equal_false:
51858
167
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
51859
167
      }
51860
391
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51861
17
      d1 = (double)Z_LVAL_P(op1);
51862
17
      d2 = Z_DVAL_P(op2);
51863
17
      goto is_not_equal_double;
51864
17
    }
51865
4.24k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51866
30
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51867
30
      d1 = Z_DVAL_P(op1);
51868
30
      d2 = Z_DVAL_P(op2);
51869
47
is_not_equal_double:
51870
47
      if (d1 != d2) {
51871
47
        goto is_not_equal_true;
51872
47
      } else {
51873
0
        goto is_not_equal_false;
51874
0
      }
51875
47
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51876
0
      d1 = Z_DVAL_P(op1);
51877
0
      d2 = (double)Z_LVAL_P(op2);
51878
0
      goto is_not_equal_double;
51879
0
    }
51880
4.21k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51881
442
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51882
133
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51883
133
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51884
0
        zval_ptr_dtor_str(op1);
51885
0
      }
51886
133
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51887
0
        zval_ptr_dtor_str(op2);
51888
0
      }
51889
133
      if (!result) {
51890
48
        goto is_not_equal_true;
51891
85
      } else {
51892
85
        goto is_not_equal_false;
51893
85
      }
51894
133
    }
51895
442
  }
51896
4.76k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51897
4.76k
}
51898
51899
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51900
2.35k
{
51901
2.35k
  USE_OPLINE
51902
2.35k
  zval *op1, *op2;
51903
2.35k
  double d1, d2;
51904
51905
2.35k
  op1 = EX_VAR(opline->op1.var);
51906
2.35k
  op2 = EX_VAR(opline->op2.var);
51907
2.35k
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51908
    /* pass */
51909
2.35k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51910
796
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51911
778
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51912
728
is_not_equal_true:
51913
728
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
51914
728
      } else {
51915
86
is_not_equal_false:
51916
86
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
51917
86
      }
51918
778
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51919
18
      d1 = (double)Z_LVAL_P(op1);
51920
18
      d2 = Z_DVAL_P(op2);
51921
18
      goto is_not_equal_double;
51922
18
    }
51923
1.55k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51924
20
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51925
18
      d1 = Z_DVAL_P(op1);
51926
18
      d2 = Z_DVAL_P(op2);
51927
36
is_not_equal_double:
51928
36
      if (d1 != d2) {
51929
36
        goto is_not_equal_true;
51930
36
      } else {
51931
0
        goto is_not_equal_false;
51932
0
      }
51933
36
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51934
0
      d1 = Z_DVAL_P(op1);
51935
0
      d2 = (double)Z_LVAL_P(op2);
51936
0
      goto is_not_equal_double;
51937
0
    }
51938
1.53k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51939
483
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51940
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51941
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51942
0
        zval_ptr_dtor_str(op1);
51943
0
      }
51944
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51945
0
        zval_ptr_dtor_str(op2);
51946
0
      }
51947
0
      if (!result) {
51948
0
        goto is_not_equal_true;
51949
0
      } else {
51950
0
        goto is_not_equal_false;
51951
0
      }
51952
0
    }
51953
483
  }
51954
2.35k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51955
2.35k
}
51956
51957
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51958
3.33k
{
51959
3.33k
  USE_OPLINE
51960
3.33k
  zval *op1, *op2;
51961
3.33k
  double d1, d2;
51962
51963
3.33k
  op1 = EX_VAR(opline->op1.var);
51964
3.33k
  op2 = EX_VAR(opline->op2.var);
51965
3.33k
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51966
    /* pass */
51967
3.33k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51968
1.66k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51969
1.61k
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51970
1.52k
is_not_equal_true:
51971
1.52k
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
51972
1.52k
      } else {
51973
189
is_not_equal_false:
51974
189
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
51975
189
      }
51976
1.61k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51977
51
      d1 = (double)Z_LVAL_P(op1);
51978
51
      d2 = Z_DVAL_P(op2);
51979
51
      goto is_not_equal_double;
51980
51
    }
51981
1.67k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51982
49
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51983
49
      d1 = Z_DVAL_P(op1);
51984
49
      d2 = Z_DVAL_P(op2);
51985
100
is_not_equal_double:
51986
100
      if (d1 != d2) {
51987
64
        goto is_not_equal_true;
51988
64
      } else {
51989
36
        goto is_not_equal_false;
51990
36
      }
51991
100
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51992
0
      d1 = Z_DVAL_P(op1);
51993
0
      d2 = (double)Z_LVAL_P(op2);
51994
0
      goto is_not_equal_double;
51995
0
    }
51996
1.62k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51997
130
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51998
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51999
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52000
0
        zval_ptr_dtor_str(op1);
52001
0
      }
52002
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52003
0
        zval_ptr_dtor_str(op2);
52004
0
      }
52005
0
      if (!result) {
52006
0
        goto is_not_equal_true;
52007
0
      } else {
52008
0
        goto is_not_equal_false;
52009
0
      }
52010
0
    }
52011
130
  }
52012
3.33k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
52013
3.33k
}
52014
52015
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52016
36
{
52017
36
  USE_OPLINE
52018
36
  zval *op1, *op2;
52019
52020
36
  SAVE_OPLINE();
52021
36
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
52022
36
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52023
36
  compare_function(EX_VAR(opline->result.var), op1, op2);
52024
52025
52026
36
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52027
36
}
52028
52029
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52030
0
{
52031
0
  USE_OPLINE
52032
0
  zval *op1, *op2;
52033
52034
0
  SAVE_OPLINE();
52035
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
52036
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52037
0
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
52038
52039
52040
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52041
0
}
52042
52043
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52044
233
{
52045
233
  USE_OPLINE
52046
233
  zval *object;
52047
233
  zval *property;
52048
233
  zval *value;
52049
233
  zval *zptr;
52050
233
  void *_cache_slot[3] = {0};
52051
233
  void **cache_slot;
52052
233
  zend_property_info *prop_info;
52053
233
  zend_object *zobj;
52054
233
  zend_string *name, *tmp_name;
52055
52056
233
  SAVE_OPLINE();
52057
233
  object = EX_VAR(opline->op1.var);
52058
233
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52059
52060
233
  do {
52061
233
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
52062
52063
233
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52064
14
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52065
0
        object = Z_REFVAL_P(object);
52066
0
        goto assign_op_object;
52067
0
      }
52068
14
      if (IS_CV == IS_CV
52069
14
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52070
14
        ZVAL_UNDEFINED_OP1();
52071
14
      }
52072
14
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52073
14
      break;
52074
14
    }
52075
52076
219
assign_op_object:
52077
    /* here we are sure we are dealing with an object */
52078
219
    zobj = Z_OBJ_P(object);
52079
219
    if (IS_CV == IS_CONST) {
52080
0
      name = Z_STR_P(property);
52081
219
    } else {
52082
219
      name = zval_try_get_tmp_string(property, &tmp_name);
52083
219
      if (UNEXPECTED(!name)) {
52084
0
        UNDEF_RESULT();
52085
0
        break;
52086
0
      }
52087
219
    }
52088
219
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
52089
219
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52090
219
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52091
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52092
0
          ZVAL_NULL(EX_VAR(opline->result.var));
52093
0
        }
52094
219
      } else {
52095
219
        zend_reference *ref;
52096
52097
219
        do {
52098
219
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
52099
0
            ref = Z_REF_P(zptr);
52100
0
            zptr = Z_REFVAL_P(zptr);
52101
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52102
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52103
0
              break;
52104
0
            }
52105
0
          }
52106
52107
219
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
52108
219
          if (prop_info) {
52109
            /* special case for typed properties */
52110
18
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
52111
201
          } else {
52112
201
            zend_binary_op(zptr, zptr, value OPLINE_CC);
52113
201
          }
52114
219
        } while (0);
52115
52116
219
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52117
39
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
52118
39
        }
52119
219
      }
52120
219
    } else {
52121
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
52122
0
    }
52123
219
    if (IS_CV != IS_CONST) {
52124
219
      zend_tmp_string_release(tmp_name);
52125
219
    }
52126
219
  } while (0);
52127
52128
233
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52129
52130
52131
  /* assign_obj has two opcodes! */
52132
233
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
52133
233
}
52134
52135
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
52136
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52137
1.82k
{
52138
1.82k
  USE_OPLINE
52139
1.82k
  zval *var_ptr;
52140
1.82k
  zval *value, *container, *dim;
52141
1.82k
  HashTable *ht;
52142
52143
1.82k
  SAVE_OPLINE();
52144
1.82k
  container = EX_VAR(opline->op1.var);
52145
52146
1.82k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52147
1.72k
assign_dim_op_array:
52148
1.72k
    SEPARATE_ARRAY(container);
52149
1.72k
    ht = Z_ARRVAL_P(container);
52150
1.81k
assign_dim_op_new_array:
52151
1.81k
    dim = EX_VAR(opline->op2.var);
52152
1.81k
    if (IS_CV == IS_UNUSED) {
52153
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
52154
0
      if (UNEXPECTED(!var_ptr)) {
52155
0
        zend_cannot_add_element();
52156
0
        goto assign_dim_op_ret_null;
52157
0
      }
52158
1.81k
    } else {
52159
1.81k
      if (IS_CV == IS_CONST) {
52160
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
52161
1.81k
      } else {
52162
1.81k
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
52163
1.81k
      }
52164
1.81k
      if (UNEXPECTED(!var_ptr)) {
52165
61
        goto assign_dim_op_ret_null;
52166
61
      }
52167
1.81k
    }
52168
52169
1.75k
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
52170
52171
1.75k
    do {
52172
1.75k
      if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
52173
0
        zend_reference *ref = Z_REF_P(var_ptr);
52174
0
        var_ptr = Z_REFVAL_P(var_ptr);
52175
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52176
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52177
0
          break;
52178
0
        }
52179
0
      }
52180
1.75k
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
52181
1.75k
    } while (0);
52182
52183
1.75k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52184
110
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
52185
110
    }
52186
1.75k
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52187
1.75k
  } else {
52188
95
    if (EXPECTED(Z_ISREF_P(container))) {
52189
0
      container = Z_REFVAL_P(container);
52190
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52191
0
        goto assign_dim_op_array;
52192
0
      }
52193
0
    }
52194
52195
95
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52196
5
      zend_object *obj = Z_OBJ_P(container);
52197
52198
5
      dim = EX_VAR(opline->op2.var);
52199
5
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52200
0
        dim++;
52201
0
      }
52202
5
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
52203
90
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
52204
90
      uint8_t old_type;
52205
52206
90
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
52207
52
        ZVAL_UNDEFINED_OP1();
52208
52
      }
52209
90
      ht = zend_new_array(8);
52210
90
      old_type = Z_TYPE_P(container);
52211
90
      ZVAL_ARR(container, ht);
52212
90
      if (UNEXPECTED(old_type == IS_FALSE)) {
52213
0
        GC_ADDREF(ht);
52214
0
        zend_false_to_array_deprecated();
52215
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52216
0
          zend_array_destroy(ht);
52217
0
          goto assign_dim_op_ret_null;
52218
0
        }
52219
0
      }
52220
90
      goto assign_dim_op_new_array;
52221
90
    } else {
52222
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52223
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
52224
61
assign_dim_op_ret_null:
52225
61
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52226
61
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52227
2
        ZVAL_NULL(EX_VAR(opline->result.var));
52228
2
      }
52229
61
    }
52230
95
  }
52231
52232
52233
1.82k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
52234
1.82k
}
52235
52236
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52237
20.6k
{
52238
20.6k
  USE_OPLINE
52239
20.6k
  zval *var_ptr;
52240
20.6k
  zval *value;
52241
52242
20.6k
  SAVE_OPLINE();
52243
20.6k
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52244
20.6k
  var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
52245
52246
20.6k
  do {
52247
20.6k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
52248
2.63k
      zend_reference *ref = Z_REF_P(var_ptr);
52249
2.63k
      var_ptr = Z_REFVAL_P(var_ptr);
52250
2.63k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52251
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52252
0
        break;
52253
0
      }
52254
2.63k
    }
52255
20.6k
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
52256
20.6k
  } while (0);
52257
52258
20.6k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52259
4.50k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
52260
4.50k
  }
52261
52262
52263
20.6k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52264
20.6k
}
52265
52266
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52267
33
{
52268
33
  USE_OPLINE
52269
33
  zval *object;
52270
33
  zval *property;
52271
33
  zval *zptr;
52272
33
  void *_cache_slot[3] = {0};
52273
33
  void **cache_slot;
52274
33
  zend_property_info *prop_info;
52275
33
  zend_object *zobj;
52276
33
  zend_string *name, *tmp_name;
52277
52278
33
  SAVE_OPLINE();
52279
33
  object = EX_VAR(opline->op1.var);
52280
33
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52281
52282
33
  do {
52283
33
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52284
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52285
0
        object = Z_REFVAL_P(object);
52286
0
        goto pre_incdec_object;
52287
0
      }
52288
0
      if (IS_CV == IS_CV
52289
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52290
0
        ZVAL_UNDEFINED_OP1();
52291
0
      }
52292
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52293
0
      break;
52294
0
    }
52295
52296
33
pre_incdec_object:
52297
    /* here we are sure we are dealing with an object */
52298
33
    zobj = Z_OBJ_P(object);
52299
33
    if (IS_CV == IS_CONST) {
52300
0
      name = Z_STR_P(property);
52301
33
    } else {
52302
33
      name = zval_try_get_tmp_string(property, &tmp_name);
52303
33
      if (UNEXPECTED(!name)) {
52304
0
        UNDEF_RESULT();
52305
0
        break;
52306
0
      }
52307
33
    }
52308
33
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
52309
33
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52310
33
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52311
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52312
0
          ZVAL_NULL(EX_VAR(opline->result.var));
52313
0
        }
52314
33
      } else {
52315
33
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
52316
33
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
52317
33
      }
52318
33
    } else {
52319
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
52320
0
    }
52321
33
    if (IS_CV != IS_CONST) {
52322
33
      zend_tmp_string_release(tmp_name);
52323
33
    }
52324
33
  } while (0);
52325
52326
52327
33
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52328
33
}
52329
52330
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52331
28
{
52332
28
  USE_OPLINE
52333
28
  zval *object;
52334
28
  zval *property;
52335
28
  zval *zptr;
52336
28
  void *_cache_slot[3] = {0};
52337
28
  void **cache_slot;
52338
28
  zend_property_info *prop_info;
52339
28
  zend_object *zobj;
52340
28
  zend_string *name, *tmp_name;
52341
52342
28
  SAVE_OPLINE();
52343
28
  object = EX_VAR(opline->op1.var);
52344
28
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52345
52346
28
  do {
52347
28
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52348
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52349
0
        object = Z_REFVAL_P(object);
52350
0
        goto post_incdec_object;
52351
0
      }
52352
0
      if (IS_CV == IS_CV
52353
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52354
0
        ZVAL_UNDEFINED_OP1();
52355
0
      }
52356
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52357
0
      break;
52358
0
    }
52359
52360
28
post_incdec_object:
52361
    /* here we are sure we are dealing with an object */
52362
28
    zobj = Z_OBJ_P(object);
52363
28
    if (IS_CV == IS_CONST) {
52364
0
      name = Z_STR_P(property);
52365
28
    } else {
52366
28
      name = zval_try_get_tmp_string(property, &tmp_name);
52367
28
      if (UNEXPECTED(!name)) {
52368
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
52369
0
        break;
52370
0
      }
52371
28
    }
52372
28
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
52373
28
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52374
28
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52375
0
        ZVAL_NULL(EX_VAR(opline->result.var));
52376
28
      } else {
52377
28
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
52378
28
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
52379
28
      }
52380
28
    } else {
52381
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
52382
0
    }
52383
28
    if (IS_CV != IS_CONST) {
52384
28
      zend_tmp_string_release(tmp_name);
52385
28
    }
52386
28
  } while (0);
52387
52388
52389
28
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52390
28
}
52391
52392
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52393
6.16k
{
52394
6.16k
  USE_OPLINE
52395
6.16k
  zval *container, *dim, *value;
52396
52397
6.16k
  SAVE_OPLINE();
52398
6.16k
  container = EX_VAR(opline->op1.var);
52399
6.16k
  dim = EX_VAR(opline->op2.var);
52400
6.16k
  if (IS_CV != IS_CONST) {
52401
6.16k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52402
3.24k
fetch_dim_r_array:
52403
3.24k
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
52404
3.24k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
52405
3.24k
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
52406
22
      container = Z_REFVAL_P(container);
52407
22
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52408
20
        goto fetch_dim_r_array;
52409
20
      } else {
52410
2
        goto fetch_dim_r_slow;
52411
2
      }
52412
2.92k
    } else {
52413
2.92k
fetch_dim_r_slow:
52414
2.92k
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52415
0
        dim++;
52416
0
      }
52417
2.92k
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
52418
2.92k
    }
52419
6.16k
  } else {
52420
0
    zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
52421
0
  }
52422
52423
52424
6.16k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52425
6.16k
}
52426
52427
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52428
5.55k
{
52429
5.55k
  USE_OPLINE
52430
5.55k
  zval *container;
52431
52432
5.55k
  SAVE_OPLINE();
52433
5.55k
  container = EX_VAR(opline->op1.var);
52434
5.55k
  zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52435
52436
5.55k
  if (IS_CV == IS_VAR) {
52437
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52438
0
  }
52439
5.55k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52440
5.55k
}
52441
52442
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52443
53
{
52444
53
  USE_OPLINE
52445
53
  zval *container;
52446
52447
53
  SAVE_OPLINE();
52448
53
  container = EX_VAR(opline->op1.var);
52449
53
  zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52450
52451
53
  if (IS_CV == IS_VAR) {
52452
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52453
0
  }
52454
53
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52455
53
}
52456
52457
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52458
65
{
52459
65
  USE_OPLINE
52460
65
  zval *container;
52461
52462
65
  SAVE_OPLINE();
52463
65
  container = EX_VAR(opline->op1.var);
52464
65
  zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52465
52466
52467
65
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52468
65
}
52469
52470
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52471
0
{
52472
#if 0
52473
  USE_OPLINE
52474
#endif
52475
52476
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
52477
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
52478
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52479
0
    }
52480
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52481
0
  } else {
52482
0
    if (IS_CV == IS_UNUSED) {
52483
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52484
0
    }
52485
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52486
0
  }
52487
0
}
52488
52489
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52490
0
{
52491
0
  USE_OPLINE
52492
0
  zval *container;
52493
52494
0
  SAVE_OPLINE();
52495
0
  container = EX_VAR(opline->op1.var);
52496
0
  zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52497
52498
0
  if (IS_CV == IS_VAR) {
52499
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52500
0
  }
52501
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52502
0
}
52503
52504
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52505
754
{
52506
754
  USE_OPLINE
52507
754
  zval *container;
52508
754
  void **cache_slot = NULL;
52509
52510
754
  SAVE_OPLINE();
52511
754
  container = EX_VAR(opline->op1.var);
52512
52513
754
  if (IS_CV == IS_CONST ||
52514
754
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
52515
125
    do {
52516
125
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
52517
27
        container = Z_REFVAL_P(container);
52518
27
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52519
27
          break;
52520
27
        }
52521
27
      }
52522
98
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
52523
67
        ZVAL_UNDEFINED_OP1();
52524
67
      }
52525
98
      zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52526
98
      ZVAL_NULL(EX_VAR(opline->result.var));
52527
98
      goto fetch_obj_r_finish;
52528
125
    } while (0);
52529
125
  }
52530
52531
  /* here we are sure we are dealing with an object */
52532
656
  do {
52533
656
    zend_object *zobj = Z_OBJ_P(container);
52534
656
    zend_string *name, *tmp_name;
52535
656
    zval *retval;
52536
52537
656
    if (IS_CV == IS_CONST) {
52538
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
52539
52540
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
52541
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52542
52543
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52544
0
fetch_obj_r_simple:
52545
0
          retval = OBJ_PROP(zobj, prop_offset);
52546
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
52547
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52548
0
              goto fetch_obj_r_copy;
52549
0
            } else {
52550
0
fetch_obj_r_fast_copy:
52551
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52552
0
              ZEND_VM_NEXT_OPCODE();
52553
0
            }
52554
0
          }
52555
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
52556
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52557
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
52558
0
            prop_offset = prop_info->offset;
52559
0
            goto fetch_obj_r_simple;
52560
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
52561
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
52562
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
52563
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
52564
52565
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
52566
0
            if (IS_CV & IS_CV) {
52567
0
              GC_ADDREF(zobj);
52568
0
            }
52569
0
            if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
52570
0
              call_info |= ZEND_CALL_RELEASE_THIS;
52571
0
            }
52572
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
52573
0
            call->prev_execute_data = execute_data;
52574
0
            call->call = NULL;
52575
0
            call->return_value = EX_VAR(opline->result.var);
52576
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
52577
52578
0
            execute_data = call;
52579
0
            EG(current_execute_data) = execute_data;
52580
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
52581
52582
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
52583
            opline = hook->op_array.opcodes;
52584
#else
52585
0
            EX(opline) = hook->op_array.opcodes;
52586
0
#endif
52587
0
            LOAD_OPLINE_EX();
52588
52589
52590
0
            ZEND_VM_ENTER_EX();
52591
0
          }
52592
          /* Fall through to read_property for hooks. */
52593
0
        } else if (EXPECTED(zobj->properties != NULL)) {
52594
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
52595
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52596
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
52597
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
52598
52599
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
52600
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
52601
52602
0
              if (EXPECTED(p->key == name) ||
52603
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
52604
0
                   EXPECTED(p->key != NULL) &&
52605
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
52606
0
                retval = &p->val;
52607
0
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52608
0
                  goto fetch_obj_r_copy;
52609
0
                } else {
52610
0
                  goto fetch_obj_r_fast_copy;
52611
0
                }
52612
0
              }
52613
0
            }
52614
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
52615
0
          }
52616
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
52617
0
          if (EXPECTED(retval)) {
52618
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
52619
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
52620
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52621
0
              goto fetch_obj_r_copy;
52622
0
            } else {
52623
0
              goto fetch_obj_r_fast_copy;
52624
0
            }
52625
0
          }
52626
0
        }
52627
0
      }
52628
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52629
656
    } else {
52630
656
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52631
656
      if (UNEXPECTED(!name)) {
52632
3
        ZVAL_UNDEF(EX_VAR(opline->result.var));
52633
3
        break;
52634
3
      }
52635
656
    }
52636
52637
653
#if ZEND_DEBUG
52638
    /* For non-standard object handlers, verify a declared property type in debug builds.
52639
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
52640
653
    zend_property_info *prop_info = NULL;
52641
653
    if (zobj->handlers->read_property != zend_std_read_property) {
52642
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
52643
0
    }
52644
653
#endif
52645
653
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
52646
653
#if ZEND_DEBUG
52647
653
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
52648
653
        && ZEND_TYPE_IS_SET(prop_info->type)) {
52649
0
      ZVAL_OPT_DEREF(retval);
52650
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
52651
0
    }
52652
653
#endif
52653
52654
653
    if (IS_CV != IS_CONST) {
52655
653
      zend_tmp_string_release(tmp_name);
52656
653
    }
52657
52658
653
    if (retval != EX_VAR(opline->result.var)) {
52659
605
fetch_obj_r_copy:
52660
605
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52661
605
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
52662
0
      zend_unwrap_reference(retval);
52663
0
    }
52664
653
  } while (0);
52665
52666
754
fetch_obj_r_finish:
52667
52668
52669
754
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52670
754
}
52671
52672
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52673
665
{
52674
665
  USE_OPLINE
52675
665
  zval *property, *container, *result;
52676
52677
665
  SAVE_OPLINE();
52678
52679
665
  container = EX_VAR(opline->op1.var);
52680
665
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52681
665
  result = EX_VAR(opline->result.var);
52682
665
  zend_fetch_property_address(
52683
665
    result, container, IS_CV, property, IS_CV,
52684
665
    ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
52685
665
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
52686
52687
665
  if (IS_CV == IS_VAR) {
52688
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52689
0
  }
52690
665
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52691
665
}
52692
52693
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52694
0
{
52695
0
  USE_OPLINE
52696
0
  zval *property, *container, *result;
52697
52698
0
  SAVE_OPLINE();
52699
0
  container = EX_VAR(opline->op1.var);
52700
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52701
0
  result = EX_VAR(opline->result.var);
52702
0
  zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
52703
52704
0
  if (IS_CV == IS_VAR) {
52705
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52706
0
  }
52707
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52708
0
}
52709
52710
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52711
255
{
52712
255
  USE_OPLINE
52713
255
  zval *container;
52714
255
  void **cache_slot = NULL;
52715
52716
255
  SAVE_OPLINE();
52717
255
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
52718
52719
255
  if (IS_CV == IS_CONST ||
52720
255
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
52721
10
    do {
52722
10
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
52723
5
        container = Z_REFVAL_P(container);
52724
5
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52725
5
          break;
52726
5
        }
52727
5
      }
52728
5
      if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
52729
5
        ZVAL_UNDEFINED_OP2();
52730
5
      }
52731
5
      ZVAL_NULL(EX_VAR(opline->result.var));
52732
5
      goto fetch_obj_is_finish;
52733
10
    } while (0);
52734
10
  }
52735
52736
  /* here we are sure we are dealing with an object */
52737
250
  do {
52738
250
    zend_object *zobj = Z_OBJ_P(container);
52739
250
    zend_string *name, *tmp_name;
52740
250
    zval *retval;
52741
52742
250
    if (IS_CV == IS_CONST) {
52743
0
      cache_slot = CACHE_ADDR(opline->extended_value);
52744
52745
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
52746
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52747
52748
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52749
0
fetch_obj_is_simple:
52750
0
          retval = OBJ_PROP(zobj, prop_offset);
52751
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
52752
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52753
0
              goto fetch_obj_is_copy;
52754
0
            } else {
52755
0
fetch_obj_is_fast_copy:
52756
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52757
0
              ZEND_VM_NEXT_OPCODE();
52758
0
            }
52759
0
          }
52760
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
52761
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
52762
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52763
0
            prop_offset = prop_info->offset;
52764
0
            goto fetch_obj_is_simple;
52765
0
          }
52766
          /* Fall through to read_property for hooks. */
52767
0
        } else if (EXPECTED(zobj->properties != NULL)) {
52768
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
52769
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52770
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
52771
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
52772
52773
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
52774
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
52775
52776
0
              if (EXPECTED(p->key == name) ||
52777
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
52778
0
                   EXPECTED(p->key != NULL) &&
52779
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
52780
0
                retval = &p->val;
52781
0
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52782
0
                  goto fetch_obj_is_copy;
52783
0
                } else {
52784
0
                  goto fetch_obj_is_fast_copy;
52785
0
                }
52786
0
              }
52787
0
            }
52788
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
52789
0
          }
52790
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
52791
0
          if (EXPECTED(retval)) {
52792
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
52793
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
52794
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52795
0
              goto fetch_obj_is_copy;
52796
0
            } else {
52797
0
              goto fetch_obj_is_fast_copy;
52798
0
            }
52799
0
          }
52800
0
        }
52801
0
      }
52802
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52803
250
    } else {
52804
250
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52805
250
      if (UNEXPECTED(!name)) {
52806
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
52807
0
        break;
52808
0
      }
52809
250
    }
52810
52811
250
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
52812
52813
250
    if (IS_CV != IS_CONST) {
52814
250
      zend_tmp_string_release(tmp_name);
52815
250
    }
52816
52817
250
    if (retval != EX_VAR(opline->result.var)) {
52818
243
fetch_obj_is_copy:
52819
243
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52820
243
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
52821
0
      zend_unwrap_reference(retval);
52822
0
    }
52823
250
  } while (0);
52824
52825
255
fetch_obj_is_finish:
52826
52827
52828
255
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52829
255
}
52830
52831
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52832
0
{
52833
#if 0
52834
  USE_OPLINE
52835
#endif
52836
52837
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
52838
    /* Behave like FETCH_OBJ_W */
52839
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
52840
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52841
0
    }
52842
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52843
0
  } else {
52844
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52845
0
  }
52846
0
}
52847
52848
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52849
0
{
52850
0
  USE_OPLINE
52851
0
  zval *container, *property, *result;
52852
52853
0
  SAVE_OPLINE();
52854
0
  container = EX_VAR(opline->op1.var);
52855
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52856
0
  result = EX_VAR(opline->result.var);
52857
0
  zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC);
52858
52859
0
  if (IS_CV == IS_VAR) {
52860
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52861
0
  }
52862
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52863
0
}
52864
52865
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52866
168
{
52867
168
  USE_OPLINE
52868
168
  zval *object, *value, tmp;
52869
168
  zend_object *zobj;
52870
168
  zend_string *name, *tmp_name;
52871
168
  zend_refcounted *garbage = NULL;
52872
52873
168
  SAVE_OPLINE();
52874
168
  object = EX_VAR(opline->op1.var);
52875
168
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
52876
52877
168
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52878
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52879
0
      object = Z_REFVAL_P(object);
52880
0
      goto assign_object;
52881
0
    }
52882
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
52883
0
    value = &EG(uninitialized_zval);
52884
0
    goto free_and_exit_assign_obj;
52885
0
  }
52886
52887
168
assign_object:
52888
168
  zobj = Z_OBJ_P(object);
52889
168
  if (IS_CV == IS_CONST) {
52890
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
52891
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
52892
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52893
0
      zval *property_val;
52894
0
      zend_property_info *prop_info;
52895
52896
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52897
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
52898
52899
0
assign_obj_simple:
52900
0
        property_val = OBJ_PROP(zobj, prop_offset);
52901
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
52902
0
          if (prop_info != NULL) {
52903
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
52904
0
            goto free_and_exit_assign_obj;
52905
0
          } else {
52906
0
fast_assign_obj:
52907
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
52908
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52909
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
52910
0
            }
52911
0
            goto exit_assign_obj;
52912
0
          }
52913
0
        }
52914
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
52915
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52916
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
52917
0
          zobj = zend_lazy_object_init(zobj);
52918
0
          if (!zobj) {
52919
0
            value = &EG(uninitialized_zval);
52920
0
            goto free_and_exit_assign_obj;
52921
0
          }
52922
0
        }
52923
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52924
0
          rebuild_object_properties_internal(zobj);
52925
0
        }
52926
0
        if (EXPECTED(zobj->properties != NULL)) {
52927
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
52928
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
52929
0
              GC_DELREF(zobj->properties);
52930
0
            }
52931
0
            zobj->properties = zend_array_dup(zobj->properties);
52932
0
          }
52933
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
52934
0
          if (property_val) {
52935
0
            goto fast_assign_obj;
52936
0
          }
52937
0
        }
52938
52939
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52940
0
          if (IS_CONST == IS_CONST) {
52941
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
52942
0
              Z_ADDREF_P(value);
52943
0
            }
52944
0
          } else if (IS_CONST != IS_TMP_VAR) {
52945
0
            if (Z_ISREF_P(value)) {
52946
0
              if (IS_CONST == IS_VAR) {
52947
0
                zend_reference *ref = Z_REF_P(value);
52948
0
                if (GC_DELREF(ref) == 0) {
52949
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
52950
0
                  efree_size(ref, sizeof(zend_reference));
52951
0
                  value = &tmp;
52952
0
                } else {
52953
0
                  value = Z_REFVAL_P(value);
52954
0
                  Z_TRY_ADDREF_P(value);
52955
0
                }
52956
0
              } else {
52957
0
                value = Z_REFVAL_P(value);
52958
0
                Z_TRY_ADDREF_P(value);
52959
0
              }
52960
0
            } else if (IS_CONST == IS_CV) {
52961
0
              Z_TRY_ADDREF_P(value);
52962
0
            }
52963
0
          }
52964
0
          zend_hash_add_new(zobj->properties, name, value);
52965
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52966
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
52967
0
          }
52968
0
          goto exit_assign_obj;
52969
0
        }
52970
0
      } else {
52971
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
52972
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
52973
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
52974
0
          prop_offset = prop_info->offset;
52975
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
52976
0
            prop_info = NULL;
52977
0
          }
52978
0
          goto assign_obj_simple;
52979
0
        }
52980
        /* Fall through to write_property for hooks. */
52981
0
      }
52982
0
    }
52983
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52984
168
  } else {
52985
168
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52986
168
    if (UNEXPECTED(!name)) {
52987
52988
0
      UNDEF_RESULT();
52989
0
      goto exit_assign_obj;
52990
0
    }
52991
168
  }
52992
52993
168
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
52994
0
    ZVAL_DEREF(value);
52995
0
  }
52996
52997
168
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
52998
52999
168
  if (IS_CV != IS_CONST) {
53000
168
    zend_tmp_string_release(tmp_name);
53001
168
  }
53002
53003
168
free_and_exit_assign_obj:
53004
168
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53005
9
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53006
9
  }
53007
53008
168
exit_assign_obj:
53009
168
  if (garbage) {
53010
0
    GC_DTOR_NO_REF(garbage);
53011
0
  }
53012
53013
53014
  /* assign_obj has two opcodes! */
53015
168
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53016
168
}
53017
53018
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53019
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53020
10
{
53021
10
  USE_OPLINE
53022
10
  zval *object, *value, tmp;
53023
10
  zend_object *zobj;
53024
10
  zend_string *name, *tmp_name;
53025
10
  zend_refcounted *garbage = NULL;
53026
53027
10
  SAVE_OPLINE();
53028
10
  object = EX_VAR(opline->op1.var);
53029
10
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53030
53031
10
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53032
10
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53033
10
      object = Z_REFVAL_P(object);
53034
10
      goto assign_object;
53035
10
    }
53036
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
53037
0
    value = &EG(uninitialized_zval);
53038
0
    goto free_and_exit_assign_obj;
53039
10
  }
53040
53041
10
assign_object:
53042
10
  zobj = Z_OBJ_P(object);
53043
10
  if (IS_CV == IS_CONST) {
53044
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53045
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
53046
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53047
0
      zval *property_val;
53048
0
      zend_property_info *prop_info;
53049
53050
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53051
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53052
53053
0
assign_obj_simple:
53054
0
        property_val = OBJ_PROP(zobj, prop_offset);
53055
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
53056
0
          if (prop_info != NULL) {
53057
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53058
0
            goto free_and_exit_assign_obj;
53059
0
          } else {
53060
0
fast_assign_obj:
53061
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
53062
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53063
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
53064
0
            }
53065
0
            goto exit_assign_obj;
53066
0
          }
53067
0
        }
53068
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53069
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53070
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53071
0
          zobj = zend_lazy_object_init(zobj);
53072
0
          if (!zobj) {
53073
0
            value = &EG(uninitialized_zval);
53074
0
            goto free_and_exit_assign_obj;
53075
0
          }
53076
0
        }
53077
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53078
0
          rebuild_object_properties_internal(zobj);
53079
0
        }
53080
0
        if (EXPECTED(zobj->properties != NULL)) {
53081
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53082
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53083
0
              GC_DELREF(zobj->properties);
53084
0
            }
53085
0
            zobj->properties = zend_array_dup(zobj->properties);
53086
0
          }
53087
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
53088
0
          if (property_val) {
53089
0
            goto fast_assign_obj;
53090
0
          }
53091
0
        }
53092
53093
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53094
0
          if (IS_TMP_VAR == IS_CONST) {
53095
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53096
0
              Z_ADDREF_P(value);
53097
0
            }
53098
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
53099
0
            if (Z_ISREF_P(value)) {
53100
0
              if (IS_TMP_VAR == IS_VAR) {
53101
0
                zend_reference *ref = Z_REF_P(value);
53102
0
                if (GC_DELREF(ref) == 0) {
53103
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53104
0
                  efree_size(ref, sizeof(zend_reference));
53105
0
                  value = &tmp;
53106
0
                } else {
53107
0
                  value = Z_REFVAL_P(value);
53108
0
                  Z_TRY_ADDREF_P(value);
53109
0
                }
53110
0
              } else {
53111
0
                value = Z_REFVAL_P(value);
53112
0
                Z_TRY_ADDREF_P(value);
53113
0
              }
53114
0
            } else if (IS_TMP_VAR == IS_CV) {
53115
0
              Z_TRY_ADDREF_P(value);
53116
0
            }
53117
0
          }
53118
0
          zend_hash_add_new(zobj->properties, name, value);
53119
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53120
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
53121
0
          }
53122
0
          goto exit_assign_obj;
53123
0
        }
53124
0
      } else {
53125
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53126
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53127
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
53128
0
          prop_offset = prop_info->offset;
53129
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53130
0
            prop_info = NULL;
53131
0
          }
53132
0
          goto assign_obj_simple;
53133
0
        }
53134
        /* Fall through to write_property for hooks. */
53135
0
      }
53136
0
    }
53137
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53138
10
  } else {
53139
10
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53140
10
    if (UNEXPECTED(!name)) {
53141
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53142
0
      UNDEF_RESULT();
53143
0
      goto exit_assign_obj;
53144
0
    }
53145
10
  }
53146
53147
10
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
53148
0
    ZVAL_DEREF(value);
53149
0
  }
53150
53151
10
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53152
53153
10
  if (IS_CV != IS_CONST) {
53154
10
    zend_tmp_string_release(tmp_name);
53155
10
  }
53156
53157
10
free_and_exit_assign_obj:
53158
10
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53159
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53160
0
  }
53161
10
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53162
10
exit_assign_obj:
53163
10
  if (garbage) {
53164
0
    GC_DTOR_NO_REF(garbage);
53165
0
  }
53166
53167
53168
  /* assign_obj has two opcodes! */
53169
10
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53170
10
}
53171
53172
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53173
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53174
186
{
53175
186
  USE_OPLINE
53176
186
  zval *object, *value, tmp;
53177
186
  zend_object *zobj;
53178
186
  zend_string *name, *tmp_name;
53179
186
  zend_refcounted *garbage = NULL;
53180
53181
186
  SAVE_OPLINE();
53182
186
  object = EX_VAR(opline->op1.var);
53183
186
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53184
53185
186
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53186
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53187
0
      object = Z_REFVAL_P(object);
53188
0
      goto assign_object;
53189
0
    }
53190
0
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
53191
0
    value = &EG(uninitialized_zval);
53192
0
    goto free_and_exit_assign_obj;
53193
0
  }
53194
53195
186
assign_object:
53196
186
  zobj = Z_OBJ_P(object);
53197
186
  if (IS_CV == IS_CONST) {
53198
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53199
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
53200
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53201
0
      zval *property_val;
53202
0
      zend_property_info *prop_info;
53203
53204
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53205
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53206
53207
0
assign_obj_simple:
53208
0
        property_val = OBJ_PROP(zobj, prop_offset);
53209
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
53210
0
          if (prop_info != NULL) {
53211
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53212
0
            goto free_and_exit_assign_obj;
53213
0
          } else {
53214
0
fast_assign_obj:
53215
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
53216
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53217
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
53218
0
            }
53219
0
            goto exit_assign_obj;
53220
0
          }
53221
0
        }
53222
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53223
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53224
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53225
0
          zobj = zend_lazy_object_init(zobj);
53226
0
          if (!zobj) {
53227
0
            value = &EG(uninitialized_zval);
53228
0
            goto free_and_exit_assign_obj;
53229
0
          }
53230
0
        }
53231
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53232
0
          rebuild_object_properties_internal(zobj);
53233
0
        }
53234
0
        if (EXPECTED(zobj->properties != NULL)) {
53235
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53236
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53237
0
              GC_DELREF(zobj->properties);
53238
0
            }
53239
0
            zobj->properties = zend_array_dup(zobj->properties);
53240
0
          }
53241
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
53242
0
          if (property_val) {
53243
0
            goto fast_assign_obj;
53244
0
          }
53245
0
        }
53246
53247
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53248
0
          if (IS_VAR == IS_CONST) {
53249
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53250
0
              Z_ADDREF_P(value);
53251
0
            }
53252
0
          } else if (IS_VAR != IS_TMP_VAR) {
53253
0
            if (Z_ISREF_P(value)) {
53254
0
              if (IS_VAR == IS_VAR) {
53255
0
                zend_reference *ref = Z_REF_P(value);
53256
0
                if (GC_DELREF(ref) == 0) {
53257
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53258
0
                  efree_size(ref, sizeof(zend_reference));
53259
0
                  value = &tmp;
53260
0
                } else {
53261
0
                  value = Z_REFVAL_P(value);
53262
0
                  Z_TRY_ADDREF_P(value);
53263
0
                }
53264
0
              } else {
53265
0
                value = Z_REFVAL_P(value);
53266
0
                Z_TRY_ADDREF_P(value);
53267
0
              }
53268
0
            } else if (IS_VAR == IS_CV) {
53269
0
              Z_TRY_ADDREF_P(value);
53270
0
            }
53271
0
          }
53272
0
          zend_hash_add_new(zobj->properties, name, value);
53273
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53274
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
53275
0
          }
53276
0
          goto exit_assign_obj;
53277
0
        }
53278
0
      } else {
53279
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53280
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53281
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
53282
0
          prop_offset = prop_info->offset;
53283
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53284
0
            prop_info = NULL;
53285
0
          }
53286
0
          goto assign_obj_simple;
53287
0
        }
53288
        /* Fall through to write_property for hooks. */
53289
0
      }
53290
0
    }
53291
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53292
186
  } else {
53293
186
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53294
186
    if (UNEXPECTED(!name)) {
53295
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53296
0
      UNDEF_RESULT();
53297
0
      goto exit_assign_obj;
53298
0
    }
53299
186
  }
53300
53301
186
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
53302
186
    ZVAL_DEREF(value);
53303
186
  }
53304
53305
186
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53306
53307
186
  if (IS_CV != IS_CONST) {
53308
186
    zend_tmp_string_release(tmp_name);
53309
186
  }
53310
53311
186
free_and_exit_assign_obj:
53312
186
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53313
2
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53314
2
  }
53315
186
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53316
186
exit_assign_obj:
53317
186
  if (garbage) {
53318
0
    GC_DTOR_NO_REF(garbage);
53319
0
  }
53320
53321
53322
  /* assign_obj has two opcodes! */
53323
186
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53324
186
}
53325
53326
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53327
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53328
683
{
53329
683
  USE_OPLINE
53330
683
  zval *object, *value, tmp;
53331
683
  zend_object *zobj;
53332
683
  zend_string *name, *tmp_name;
53333
683
  zend_refcounted *garbage = NULL;
53334
53335
683
  SAVE_OPLINE();
53336
683
  object = EX_VAR(opline->op1.var);
53337
683
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
53338
53339
683
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53340
7
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53341
0
      object = Z_REFVAL_P(object);
53342
0
      goto assign_object;
53343
0
    }
53344
7
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
53345
7
    value = &EG(uninitialized_zval);
53346
7
    goto free_and_exit_assign_obj;
53347
7
  }
53348
53349
676
assign_object:
53350
676
  zobj = Z_OBJ_P(object);
53351
676
  if (IS_CV == IS_CONST) {
53352
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53353
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
53354
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53355
0
      zval *property_val;
53356
0
      zend_property_info *prop_info;
53357
53358
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53359
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53360
53361
0
assign_obj_simple:
53362
0
        property_val = OBJ_PROP(zobj, prop_offset);
53363
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
53364
0
          if (prop_info != NULL) {
53365
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53366
0
            goto free_and_exit_assign_obj;
53367
0
          } else {
53368
0
fast_assign_obj:
53369
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
53370
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53371
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
53372
0
            }
53373
0
            goto exit_assign_obj;
53374
0
          }
53375
0
        }
53376
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53377
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53378
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53379
0
          zobj = zend_lazy_object_init(zobj);
53380
0
          if (!zobj) {
53381
0
            value = &EG(uninitialized_zval);
53382
0
            goto free_and_exit_assign_obj;
53383
0
          }
53384
0
        }
53385
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53386
0
          rebuild_object_properties_internal(zobj);
53387
0
        }
53388
0
        if (EXPECTED(zobj->properties != NULL)) {
53389
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53390
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53391
0
              GC_DELREF(zobj->properties);
53392
0
            }
53393
0
            zobj->properties = zend_array_dup(zobj->properties);
53394
0
          }
53395
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
53396
0
          if (property_val) {
53397
0
            goto fast_assign_obj;
53398
0
          }
53399
0
        }
53400
53401
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53402
0
          if (IS_CV == IS_CONST) {
53403
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53404
0
              Z_ADDREF_P(value);
53405
0
            }
53406
0
          } else if (IS_CV != IS_TMP_VAR) {
53407
0
            if (Z_ISREF_P(value)) {
53408
0
              if (IS_CV == IS_VAR) {
53409
0
                zend_reference *ref = Z_REF_P(value);
53410
0
                if (GC_DELREF(ref) == 0) {
53411
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53412
0
                  efree_size(ref, sizeof(zend_reference));
53413
0
                  value = &tmp;
53414
0
                } else {
53415
0
                  value = Z_REFVAL_P(value);
53416
0
                  Z_TRY_ADDREF_P(value);
53417
0
                }
53418
0
              } else {
53419
0
                value = Z_REFVAL_P(value);
53420
0
                Z_TRY_ADDREF_P(value);
53421
0
              }
53422
0
            } else if (IS_CV == IS_CV) {
53423
0
              Z_TRY_ADDREF_P(value);
53424
0
            }
53425
0
          }
53426
0
          zend_hash_add_new(zobj->properties, name, value);
53427
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53428
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
53429
0
          }
53430
0
          goto exit_assign_obj;
53431
0
        }
53432
0
      } else {
53433
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53434
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53435
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
53436
0
          prop_offset = prop_info->offset;
53437
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53438
0
            prop_info = NULL;
53439
0
          }
53440
0
          goto assign_obj_simple;
53441
0
        }
53442
        /* Fall through to write_property for hooks. */
53443
0
      }
53444
0
    }
53445
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53446
676
  } else {
53447
676
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53448
676
    if (UNEXPECTED(!name)) {
53449
53450
16
      UNDEF_RESULT();
53451
16
      goto exit_assign_obj;
53452
16
    }
53453
676
  }
53454
53455
660
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
53456
660
    ZVAL_DEREF(value);
53457
660
  }
53458
53459
660
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53460
53461
660
  if (IS_CV != IS_CONST) {
53462
660
    zend_tmp_string_release(tmp_name);
53463
660
  }
53464
53465
667
free_and_exit_assign_obj:
53466
667
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53467
18
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53468
18
  }
53469
53470
683
exit_assign_obj:
53471
683
  if (garbage) {
53472
0
    GC_DTOR_NO_REF(garbage);
53473
0
  }
53474
53475
53476
  /* assign_obj has two opcodes! */
53477
683
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53478
683
}
53479
53480
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53481
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53482
4.37k
{
53483
4.37k
  USE_OPLINE
53484
4.37k
  zval *object_ptr, *orig_object_ptr;
53485
4.37k
  zval *value;
53486
4.37k
  zval *variable_ptr;
53487
4.37k
  zval *dim;
53488
4.37k
  zend_refcounted *garbage = NULL;
53489
53490
4.37k
  SAVE_OPLINE();
53491
4.37k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53492
53493
4.37k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53494
4.07k
try_assign_dim_array:
53495
4.07k
    SEPARATE_ARRAY(object_ptr);
53496
4.07k
    if (IS_CV == IS_UNUSED) {
53497
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
53498
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53499
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
53500
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53501
0
          GC_ADDREF(ht);
53502
0
        }
53503
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53504
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53505
0
          zend_array_destroy(ht);
53506
0
          goto assign_dim_error;
53507
0
        }
53508
0
      }
53509
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
53510
0
        ZVAL_DEREF(value);
53511
0
      }
53512
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53513
0
      if (UNEXPECTED(value == NULL)) {
53514
0
        zend_cannot_add_element();
53515
0
        goto assign_dim_error;
53516
0
      } else if (IS_CONST == IS_CV) {
53517
0
        if (Z_REFCOUNTED_P(value)) {
53518
0
          Z_ADDREF_P(value);
53519
0
        }
53520
0
      } else if (IS_CONST == IS_VAR) {
53521
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
53522
0
        if (Z_ISREF_P(free_op_data)) {
53523
0
          if (Z_REFCOUNTED_P(value)) {
53524
0
            Z_ADDREF_P(value);
53525
0
          }
53526
0
          zval_ptr_dtor_nogc(free_op_data);
53527
0
        }
53528
0
      } else if (IS_CONST == IS_CONST) {
53529
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53530
0
          Z_ADDREF_P(value);
53531
0
        }
53532
0
      }
53533
4.07k
    } else {
53534
4.07k
      dim = EX_VAR(opline->op2.var);
53535
4.07k
      if (IS_CV == IS_CONST) {
53536
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53537
4.07k
      } else {
53538
4.07k
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53539
4.07k
      }
53540
4.07k
      if (UNEXPECTED(variable_ptr == NULL)) {
53541
59
        goto assign_dim_error;
53542
59
      }
53543
4.02k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
53544
4.02k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
53545
4.02k
    }
53546
4.02k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53547
35
      ZVAL_COPY(EX_VAR(opline->result.var), value);
53548
35
    }
53549
4.02k
    if (garbage) {
53550
0
      GC_DTOR_NO_REF(garbage);
53551
0
    }
53552
4.02k
  } else {
53553
471
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
53554
62
      object_ptr = Z_REFVAL_P(object_ptr);
53555
62
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53556
62
        goto try_assign_dim_array;
53557
62
      }
53558
62
    }
53559
409
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53560
254
      zend_object *obj = Z_OBJ_P(object_ptr);
53561
53562
254
      GC_ADDREF(obj);
53563
254
      dim = EX_VAR(opline->op2.var);
53564
254
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53565
19
        dim = ZVAL_UNDEFINED_OP2();
53566
235
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53567
0
        dim++;
53568
0
      }
53569
53570
254
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
53571
254
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53572
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53573
254
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
53574
0
        ZVAL_DEREF(value);
53575
0
      }
53576
53577
254
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53578
53579
254
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53580
15
        zend_objects_store_del(obj);
53581
15
      }
53582
254
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53583
42
      if (IS_CV == IS_UNUSED) {
53584
0
        zend_use_new_element_for_string();
53585
53586
0
        UNDEF_RESULT();
53587
42
      } else {
53588
42
        dim = EX_VAR(opline->op2.var);
53589
42
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
53590
42
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53591
53592
42
      }
53593
113
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53594
113
      if (Z_ISREF_P(orig_object_ptr)
53595
113
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53596
113
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53597
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53598
53599
0
        UNDEF_RESULT();
53600
113
      } else {
53601
113
        HashTable *ht = zend_new_array(8);
53602
113
        uint8_t old_type = Z_TYPE_P(object_ptr);
53603
53604
113
        ZVAL_ARR(object_ptr, ht);
53605
113
        if (UNEXPECTED(old_type == IS_FALSE)) {
53606
0
          GC_ADDREF(ht);
53607
0
          zend_false_to_array_deprecated();
53608
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53609
0
            zend_array_destroy(ht);
53610
0
            goto assign_dim_error;
53611
0
          }
53612
0
        }
53613
113
        goto try_assign_dim_array;
53614
113
      }
53615
113
    } else {
53616
0
      zend_use_scalar_as_array();
53617
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53618
59
assign_dim_error:
53619
53620
59
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53621
31
        ZVAL_NULL(EX_VAR(opline->result.var));
53622
31
      }
53623
59
    }
53624
409
  }
53625
4.37k
  if (IS_CV != IS_UNUSED) {
53626
53627
4.37k
  }
53628
53629
  /* assign_dim has two opcodes! */
53630
4.37k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53631
4.37k
}
53632
53633
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53634
7.50k
{
53635
7.50k
  USE_OPLINE
53636
7.50k
  zval *object_ptr, *orig_object_ptr;
53637
7.50k
  zval *value;
53638
7.50k
  zval *variable_ptr;
53639
7.50k
  zval *dim;
53640
7.50k
  zend_refcounted *garbage = NULL;
53641
53642
7.50k
  SAVE_OPLINE();
53643
7.50k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53644
53645
7.50k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53646
7.41k
try_assign_dim_array:
53647
7.41k
    SEPARATE_ARRAY(object_ptr);
53648
7.41k
    if (IS_CV == IS_UNUSED) {
53649
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53650
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53651
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
53652
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53653
0
          GC_ADDREF(ht);
53654
0
        }
53655
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53656
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53657
0
          zend_array_destroy(ht);
53658
0
          goto assign_dim_error;
53659
0
        }
53660
0
      }
53661
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
53662
0
        ZVAL_DEREF(value);
53663
0
      }
53664
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53665
0
      if (UNEXPECTED(value == NULL)) {
53666
0
        zend_cannot_add_element();
53667
0
        goto assign_dim_error;
53668
0
      } else if (IS_TMP_VAR == IS_CV) {
53669
0
        if (Z_REFCOUNTED_P(value)) {
53670
0
          Z_ADDREF_P(value);
53671
0
        }
53672
0
      } else if (IS_TMP_VAR == IS_VAR) {
53673
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
53674
0
        if (Z_ISREF_P(free_op_data)) {
53675
0
          if (Z_REFCOUNTED_P(value)) {
53676
0
            Z_ADDREF_P(value);
53677
0
          }
53678
0
          zval_ptr_dtor_nogc(free_op_data);
53679
0
        }
53680
0
      } else if (IS_TMP_VAR == IS_CONST) {
53681
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53682
0
          Z_ADDREF_P(value);
53683
0
        }
53684
0
      }
53685
7.41k
    } else {
53686
7.41k
      dim = EX_VAR(opline->op2.var);
53687
7.41k
      if (IS_CV == IS_CONST) {
53688
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53689
7.41k
      } else {
53690
7.41k
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53691
7.41k
      }
53692
7.41k
      if (UNEXPECTED(variable_ptr == NULL)) {
53693
29
        goto assign_dim_error;
53694
29
      }
53695
7.38k
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53696
7.38k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
53697
7.38k
    }
53698
7.38k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53699
4.43k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
53700
4.43k
    }
53701
7.38k
    if (garbage) {
53702
39
      GC_DTOR_NO_REF(garbage);
53703
39
    }
53704
7.38k
  } else {
53705
202
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
53706
0
      object_ptr = Z_REFVAL_P(object_ptr);
53707
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53708
0
        goto try_assign_dim_array;
53709
0
      }
53710
0
    }
53711
202
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53712
82
      zend_object *obj = Z_OBJ_P(object_ptr);
53713
53714
82
      GC_ADDREF(obj);
53715
82
      dim = EX_VAR(opline->op2.var);
53716
82
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53717
7
        dim = ZVAL_UNDEFINED_OP2();
53718
75
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53719
0
        dim++;
53720
0
      }
53721
53722
82
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53723
82
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53724
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53725
82
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
53726
0
        ZVAL_DEREF(value);
53727
0
      }
53728
53729
82
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53730
53731
82
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53732
82
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53733
0
        zend_objects_store_del(obj);
53734
0
      }
53735
120
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53736
7
      if (IS_CV == IS_UNUSED) {
53737
0
        zend_use_new_element_for_string();
53738
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53739
0
        UNDEF_RESULT();
53740
7
      } else {
53741
7
        dim = EX_VAR(opline->op2.var);
53742
7
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53743
7
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53744
7
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53745
7
      }
53746
113
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53747
113
      if (Z_ISREF_P(orig_object_ptr)
53748
113
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53749
113
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53750
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53751
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53752
0
        UNDEF_RESULT();
53753
113
      } else {
53754
113
        HashTable *ht = zend_new_array(8);
53755
113
        uint8_t old_type = Z_TYPE_P(object_ptr);
53756
53757
113
        ZVAL_ARR(object_ptr, ht);
53758
113
        if (UNEXPECTED(old_type == IS_FALSE)) {
53759
0
          GC_ADDREF(ht);
53760
0
          zend_false_to_array_deprecated();
53761
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53762
0
            zend_array_destroy(ht);
53763
0
            goto assign_dim_error;
53764
0
          }
53765
0
        }
53766
113
        goto try_assign_dim_array;
53767
113
      }
53768
113
    } else {
53769
0
      zend_use_scalar_as_array();
53770
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53771
29
assign_dim_error:
53772
29
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53773
29
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53774
9
        ZVAL_NULL(EX_VAR(opline->result.var));
53775
9
      }
53776
29
    }
53777
202
  }
53778
7.50k
  if (IS_CV != IS_UNUSED) {
53779
53780
7.50k
  }
53781
53782
  /* assign_dim has two opcodes! */
53783
7.50k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53784
7.50k
}
53785
53786
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53787
72
{
53788
72
  USE_OPLINE
53789
72
  zval *object_ptr, *orig_object_ptr;
53790
72
  zval *value;
53791
72
  zval *variable_ptr;
53792
72
  zval *dim;
53793
72
  zend_refcounted *garbage = NULL;
53794
53795
72
  SAVE_OPLINE();
53796
72
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53797
53798
72
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53799
18
try_assign_dim_array:
53800
18
    SEPARATE_ARRAY(object_ptr);
53801
18
    if (IS_CV == IS_UNUSED) {
53802
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53803
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53804
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
53805
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53806
0
          GC_ADDREF(ht);
53807
0
        }
53808
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53809
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53810
0
          zend_array_destroy(ht);
53811
0
          goto assign_dim_error;
53812
0
        }
53813
0
      }
53814
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
53815
0
        ZVAL_DEREF(value);
53816
0
      }
53817
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53818
0
      if (UNEXPECTED(value == NULL)) {
53819
0
        zend_cannot_add_element();
53820
0
        goto assign_dim_error;
53821
0
      } else if (IS_VAR == IS_CV) {
53822
0
        if (Z_REFCOUNTED_P(value)) {
53823
0
          Z_ADDREF_P(value);
53824
0
        }
53825
0
      } else if (IS_VAR == IS_VAR) {
53826
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
53827
0
        if (Z_ISREF_P(free_op_data)) {
53828
0
          if (Z_REFCOUNTED_P(value)) {
53829
0
            Z_ADDREF_P(value);
53830
0
          }
53831
0
          zval_ptr_dtor_nogc(free_op_data);
53832
0
        }
53833
0
      } else if (IS_VAR == IS_CONST) {
53834
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53835
0
          Z_ADDREF_P(value);
53836
0
        }
53837
0
      }
53838
18
    } else {
53839
18
      dim = EX_VAR(opline->op2.var);
53840
18
      if (IS_CV == IS_CONST) {
53841
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53842
18
      } else {
53843
18
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53844
18
      }
53845
18
      if (UNEXPECTED(variable_ptr == NULL)) {
53846
5
        goto assign_dim_error;
53847
5
      }
53848
13
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53849
13
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
53850
13
    }
53851
13
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53852
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
53853
0
    }
53854
13
    if (garbage) {
53855
0
      GC_DTOR_NO_REF(garbage);
53856
0
    }
53857
59
  } else {
53858
59
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
53859
0
      object_ptr = Z_REFVAL_P(object_ptr);
53860
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53861
0
        goto try_assign_dim_array;
53862
0
      }
53863
0
    }
53864
59
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53865
54
      zend_object *obj = Z_OBJ_P(object_ptr);
53866
53867
54
      GC_ADDREF(obj);
53868
54
      dim = EX_VAR(opline->op2.var);
53869
54
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53870
0
        dim = ZVAL_UNDEFINED_OP2();
53871
54
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53872
0
        dim++;
53873
0
      }
53874
53875
54
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53876
54
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53877
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53878
54
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
53879
54
        ZVAL_DEREF(value);
53880
54
      }
53881
53882
54
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53883
53884
54
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53885
54
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53886
0
        zend_objects_store_del(obj);
53887
0
      }
53888
54
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53889
0
      if (IS_CV == IS_UNUSED) {
53890
0
        zend_use_new_element_for_string();
53891
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53892
0
        UNDEF_RESULT();
53893
0
      } else {
53894
0
        dim = EX_VAR(opline->op2.var);
53895
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53896
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53897
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53898
0
      }
53899
5
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53900
5
      if (Z_ISREF_P(orig_object_ptr)
53901
5
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53902
5
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53903
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53904
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53905
0
        UNDEF_RESULT();
53906
5
      } else {
53907
5
        HashTable *ht = zend_new_array(8);
53908
5
        uint8_t old_type = Z_TYPE_P(object_ptr);
53909
53910
5
        ZVAL_ARR(object_ptr, ht);
53911
5
        if (UNEXPECTED(old_type == IS_FALSE)) {
53912
0
          GC_ADDREF(ht);
53913
0
          zend_false_to_array_deprecated();
53914
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53915
0
            zend_array_destroy(ht);
53916
0
            goto assign_dim_error;
53917
0
          }
53918
0
        }
53919
5
        goto try_assign_dim_array;
53920
5
      }
53921
5
    } else {
53922
0
      zend_use_scalar_as_array();
53923
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53924
5
assign_dim_error:
53925
5
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53926
5
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53927
0
        ZVAL_NULL(EX_VAR(opline->result.var));
53928
0
      }
53929
5
    }
53930
59
  }
53931
72
  if (IS_CV != IS_UNUSED) {
53932
53933
72
  }
53934
53935
  /* assign_dim has two opcodes! */
53936
72
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53937
72
}
53938
53939
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53940
1.63k
{
53941
1.63k
  USE_OPLINE
53942
1.63k
  zval *object_ptr, *orig_object_ptr;
53943
1.63k
  zval *value;
53944
1.63k
  zval *variable_ptr;
53945
1.63k
  zval *dim;
53946
1.63k
  zend_refcounted *garbage = NULL;
53947
53948
1.63k
  SAVE_OPLINE();
53949
1.63k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53950
53951
1.63k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53952
987
try_assign_dim_array:
53953
987
    SEPARATE_ARRAY(object_ptr);
53954
987
    if (IS_CV == IS_UNUSED) {
53955
0
      value = EX_VAR((opline+1)->op1.var);
53956
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53957
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
53958
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53959
0
          GC_ADDREF(ht);
53960
0
        }
53961
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53962
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53963
0
          zend_array_destroy(ht);
53964
0
          goto assign_dim_error;
53965
0
        }
53966
0
      }
53967
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
53968
0
        ZVAL_DEREF(value);
53969
0
      }
53970
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53971
0
      if (UNEXPECTED(value == NULL)) {
53972
0
        zend_cannot_add_element();
53973
0
        goto assign_dim_error;
53974
0
      } else if (IS_CV == IS_CV) {
53975
0
        if (Z_REFCOUNTED_P(value)) {
53976
0
          Z_ADDREF_P(value);
53977
0
        }
53978
0
      } else if (IS_CV == IS_VAR) {
53979
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
53980
0
        if (Z_ISREF_P(free_op_data)) {
53981
0
          if (Z_REFCOUNTED_P(value)) {
53982
0
            Z_ADDREF_P(value);
53983
0
          }
53984
0
          zval_ptr_dtor_nogc(free_op_data);
53985
0
        }
53986
0
      } else if (IS_CV == IS_CONST) {
53987
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53988
0
          Z_ADDREF_P(value);
53989
0
        }
53990
0
      }
53991
987
    } else {
53992
987
      dim = EX_VAR(opline->op2.var);
53993
987
      if (IS_CV == IS_CONST) {
53994
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53995
987
      } else {
53996
987
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53997
987
      }
53998
987
      if (UNEXPECTED(variable_ptr == NULL)) {
53999
15
        goto assign_dim_error;
54000
15
      }
54001
972
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
54002
972
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54003
972
    }
54004
972
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54005
133
      ZVAL_COPY(EX_VAR(opline->result.var), value);
54006
133
    }
54007
972
    if (garbage) {
54008
146
      GC_DTOR_NO_REF(garbage);
54009
146
    }
54010
973
  } else {
54011
973
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
54012
330
      object_ptr = Z_REFVAL_P(object_ptr);
54013
330
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
54014
260
        goto try_assign_dim_array;
54015
260
      }
54016
330
    }
54017
713
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
54018
645
      zend_object *obj = Z_OBJ_P(object_ptr);
54019
54020
645
      GC_ADDREF(obj);
54021
645
      dim = EX_VAR(opline->op2.var);
54022
645
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
54023
0
        dim = ZVAL_UNDEFINED_OP2();
54024
645
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
54025
0
        dim++;
54026
0
      }
54027
54028
645
      value = EX_VAR((opline+1)->op1.var);
54029
645
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
54030
4
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
54031
641
      } else if (IS_CV & (IS_CV|IS_VAR)) {
54032
641
        ZVAL_DEREF(value);
54033
641
      }
54034
54035
645
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
54036
54037
645
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
54038
0
        zend_objects_store_del(obj);
54039
0
      }
54040
645
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
54041
0
      if (IS_CV == IS_UNUSED) {
54042
0
        zend_use_new_element_for_string();
54043
54044
0
        UNDEF_RESULT();
54045
0
      } else {
54046
0
        dim = EX_VAR(opline->op2.var);
54047
0
        value = EX_VAR((opline+1)->op1.var);
54048
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
54049
54050
0
      }
54051
68
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
54052
62
      if (Z_ISREF_P(orig_object_ptr)
54053
62
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
54054
62
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
54055
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54056
54057
0
        UNDEF_RESULT();
54058
62
      } else {
54059
62
        HashTable *ht = zend_new_array(8);
54060
62
        uint8_t old_type = Z_TYPE_P(object_ptr);
54061
54062
62
        ZVAL_ARR(object_ptr, ht);
54063
62
        if (UNEXPECTED(old_type == IS_FALSE)) {
54064
0
          GC_ADDREF(ht);
54065
0
          zend_false_to_array_deprecated();
54066
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
54067
0
            zend_array_destroy(ht);
54068
0
            goto assign_dim_error;
54069
0
          }
54070
0
        }
54071
62
        goto try_assign_dim_array;
54072
62
      }
54073
62
    } else {
54074
6
      zend_use_scalar_as_array();
54075
6
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54076
21
assign_dim_error:
54077
54078
21
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54079
14
        ZVAL_NULL(EX_VAR(opline->result.var));
54080
14
      }
54081
21
    }
54082
713
  }
54083
1.63k
  if (IS_CV != IS_UNUSED) {
54084
54085
1.63k
  }
54086
54087
  /* assign_dim has two opcodes! */
54088
1.63k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
54089
1.63k
}
54090
54091
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54092
13.0k
{
54093
13.0k
  USE_OPLINE
54094
13.0k
  zval *value;
54095
13.0k
  zval *variable_ptr;
54096
54097
13.0k
  SAVE_OPLINE();
54098
13.0k
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54099
13.0k
  variable_ptr = EX_VAR(opline->op1.var);
54100
54101
13.0k
  if (0 || UNEXPECTED(0)) {
54102
0
    zend_refcounted *garbage = NULL;
54103
54104
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54105
0
    if (UNEXPECTED(0)) {
54106
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
54107
0
    }
54108
0
    if (garbage) {
54109
0
      GC_DTOR_NO_REF(garbage);
54110
0
    }
54111
13.0k
  } else {
54112
13.0k
    value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
54113
13.0k
  }
54114
54115
  /* zend_assign_to_variable() always takes care of op2, never free it! */
54116
54117
13.0k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54118
13.0k
}
54119
54120
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54121
10.8k
{
54122
10.8k
  USE_OPLINE
54123
10.8k
  zval *value;
54124
10.8k
  zval *variable_ptr;
54125
54126
10.8k
  SAVE_OPLINE();
54127
10.8k
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54128
10.8k
  variable_ptr = EX_VAR(opline->op1.var);
54129
54130
10.8k
  if (0 || UNEXPECTED(1)) {
54131
10.8k
    zend_refcounted *garbage = NULL;
54132
54133
10.8k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54134
10.8k
    if (UNEXPECTED(1)) {
54135
10.8k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
54136
10.8k
    }
54137
10.8k
    if (garbage) {
54138
1.10k
      GC_DTOR_NO_REF(garbage);
54139
1.10k
    }
54140
10.8k
  } else {
54141
0
    value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
54142
0
  }
54143
54144
  /* zend_assign_to_variable() always takes care of op2, never free it! */
54145
54146
10.8k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54147
10.8k
}
54148
54149
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54150
4.29k
{
54151
4.29k
  USE_OPLINE
54152
4.29k
  zval *variable_ptr;
54153
4.29k
  zval *value_ptr;
54154
4.29k
  zend_refcounted *garbage = NULL;
54155
54156
4.29k
  SAVE_OPLINE();
54157
4.29k
  value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
54158
4.29k
  variable_ptr = EX_VAR(opline->op1.var);
54159
54160
4.29k
  if (IS_CV == IS_VAR &&
54161
4.29k
             UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
54162
54163
0
    zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
54164
0
    variable_ptr = &EG(uninitialized_zval);
54165
4.29k
  } else if (IS_CV == IS_VAR &&
54166
4.29k
             opline->extended_value == ZEND_RETURNS_FUNCTION &&
54167
4.29k
         UNEXPECTED(!Z_ISREF_P(value_ptr))) {
54168
54169
0
    variable_ptr = zend_wrong_assign_to_variable_reference(
54170
0
      variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
54171
4.29k
  } else {
54172
4.29k
    zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
54173
4.29k
  }
54174
54175
4.29k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54176
2.43k
    ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
54177
2.43k
  }
54178
54179
4.29k
  if (garbage) {
54180
2.26k
    GC_DTOR(garbage);
54181
2.26k
  }
54182
54183
54184
4.29k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54185
4.29k
}
54186
54187
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54188
394
{
54189
394
  USE_OPLINE
54190
394
  zval *property, *container, *value_ptr;
54191
54192
394
  SAVE_OPLINE();
54193
54194
394
  container = EX_VAR(opline->op1.var);
54195
394
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54196
54197
394
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
54198
54199
394
  if (1) {
54200
394
    if (IS_CV == IS_UNUSED) {
54201
0
      if (IS_CV == IS_CONST) {
54202
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54203
0
      } else {
54204
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54205
0
      }
54206
394
    } else {
54207
394
      if (IS_CV == IS_CONST) {
54208
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54209
394
      } else {
54210
394
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54211
394
      }
54212
394
    }
54213
394
  } else {
54214
0
    zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54215
0
  }
54216
54217
54218
394
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
54219
394
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
54220
394
}
54221
54222
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
54223
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54224
60
{
54225
60
  USE_OPLINE
54226
60
  zval *property, *container, *value_ptr;
54227
54228
60
  SAVE_OPLINE();
54229
54230
60
  container = EX_VAR(opline->op1.var);
54231
60
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54232
54233
60
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
54234
54235
60
  if (1) {
54236
60
    if (IS_CV == IS_UNUSED) {
54237
0
      if (IS_CV == IS_CONST) {
54238
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54239
0
      } else {
54240
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54241
0
      }
54242
60
    } else {
54243
60
      if (IS_CV == IS_CONST) {
54244
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54245
60
      } else {
54246
60
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54247
60
      }
54248
60
    }
54249
60
  } else {
54250
0
    zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54251
0
  }
54252
54253
54254
54255
60
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
54256
60
}
54257
54258
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
54259
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54260
891
{
54261
891
  USE_OPLINE
54262
891
  zval *op1, *op2;
54263
891
  zend_string *op1_str, *op2_str, *str;
54264
54265
54266
891
  op1 = EX_VAR(opline->op1.var);
54267
891
  op2 = EX_VAR(opline->op2.var);
54268
891
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
54269
891
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
54270
0
    zend_string *op1_str = Z_STR_P(op1);
54271
0
    zend_string *op2_str = Z_STR_P(op2);
54272
0
    zend_string *str;
54273
0
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
54274
54275
0
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
54276
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
54277
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
54278
0
      } else {
54279
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
54280
0
      }
54281
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54282
0
        zend_string_release_ex(op1_str, 0);
54283
0
      }
54284
0
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
54285
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
54286
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
54287
0
      } else {
54288
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
54289
0
      }
54290
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54291
0
        zend_string_release_ex(op2_str, 0);
54292
0
      }
54293
0
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
54294
0
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
54295
0
      size_t len = ZSTR_LEN(op1_str);
54296
54297
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
54298
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54299
0
      GC_ADD_FLAGS(str, flags);
54300
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54301
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54302
0
        zend_string_release_ex(op2_str, 0);
54303
0
      }
54304
0
    } else {
54305
0
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
54306
0
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
54307
0
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54308
0
      GC_ADD_FLAGS(str, flags);
54309
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54310
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54311
0
        zend_string_release_ex(op1_str, 0);
54312
0
      }
54313
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54314
0
        zend_string_release_ex(op2_str, 0);
54315
0
      }
54316
0
    }
54317
0
    ZEND_VM_NEXT_OPCODE();
54318
0
  }
54319
54320
891
  SAVE_OPLINE();
54321
891
  if (IS_CV == IS_CONST) {
54322
0
    op1_str = Z_STR_P(op1);
54323
891
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
54324
10
    op1_str = zend_string_copy(Z_STR_P(op1));
54325
881
  } else {
54326
881
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
54327
588
      ZVAL_UNDEFINED_OP1();
54328
588
    }
54329
881
    op1_str = zval_get_string_func(op1);
54330
881
  }
54331
891
  if (IS_CV == IS_CONST) {
54332
0
    op2_str = Z_STR_P(op2);
54333
891
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
54334
220
    op2_str = zend_string_copy(Z_STR_P(op2));
54335
671
  } else {
54336
671
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
54337
577
      ZVAL_UNDEFINED_OP2();
54338
577
    }
54339
671
    op2_str = zval_get_string_func(op2);
54340
671
  }
54341
891
  do {
54342
891
    if (IS_CV != IS_CONST) {
54343
891
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
54344
599
        if (IS_CV == IS_CONST) {
54345
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
54346
0
            GC_ADDREF(op2_str);
54347
0
          }
54348
0
        }
54349
599
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
54350
599
        zend_string_release_ex(op1_str, 0);
54351
599
        break;
54352
599
      }
54353
891
    }
54354
292
    if (IS_CV != IS_CONST) {
54355
292
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
54356
212
        if (IS_CV == IS_CONST) {
54357
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
54358
0
            GC_ADDREF(op1_str);
54359
0
          }
54360
0
        }
54361
212
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
54362
212
        zend_string_release_ex(op2_str, 0);
54363
212
        break;
54364
212
      }
54365
292
    }
54366
80
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
54367
80
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
54368
80
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54369
54370
80
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
54371
80
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54372
80
    if (IS_CV != IS_CONST) {
54373
80
      zend_string_release_ex(op1_str, 0);
54374
80
    }
54375
80
    if (IS_CV != IS_CONST) {
54376
80
      zend_string_release_ex(op2_str, 0);
54377
80
    }
54378
80
  } while (0);
54379
54380
54381
891
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54382
891
}
54383
54384
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54385
284
{
54386
284
  USE_OPLINE
54387
284
  zval *function_name;
54388
284
  zval *object;
54389
284
  zend_function *fbc;
54390
284
  zend_class_entry *called_scope;
54391
284
  zend_object *obj;
54392
284
  zend_execute_data *call;
54393
284
  uint32_t call_info;
54394
54395
284
  SAVE_OPLINE();
54396
54397
284
  object = EX_VAR(opline->op1.var);
54398
54399
284
  if (IS_CV != IS_CONST) {
54400
284
    function_name = EX_VAR(opline->op2.var);
54401
284
  }
54402
54403
284
  if (IS_CV != IS_CONST &&
54404
284
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
54405
15
    do {
54406
15
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
54407
7
        function_name = Z_REFVAL_P(function_name);
54408
7
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
54409
5
          break;
54410
5
        }
54411
8
      } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
54412
3
        ZVAL_UNDEFINED_OP2();
54413
3
        if (UNEXPECTED(EG(exception) != NULL)) {
54414
54415
0
          HANDLE_EXCEPTION();
54416
0
        }
54417
3
      }
54418
10
      zend_throw_error(NULL, "Method name must be a string");
54419
54420
54421
10
      HANDLE_EXCEPTION();
54422
10
    } while (0);
54423
15
  }
54424
54425
274
  if (IS_CV == IS_UNUSED) {
54426
0
    obj = Z_OBJ_P(object);
54427
274
  } else {
54428
274
    do {
54429
274
      if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
54430
266
        obj = Z_OBJ_P(object);
54431
266
      } else {
54432
8
        if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
54433
5
          zend_reference *ref = Z_REF_P(object);
54434
54435
5
          object = &ref->val;
54436
5
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
54437
5
            obj = Z_OBJ_P(object);
54438
5
            if (IS_CV & IS_VAR) {
54439
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
54440
0
                efree_size(ref, sizeof(zend_reference));
54441
0
              } else {
54442
0
                Z_ADDREF_P(object);
54443
0
              }
54444
0
            }
54445
5
            break;
54446
5
          }
54447
5
        }
54448
3
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
54449
3
          object = ZVAL_UNDEFINED_OP1();
54450
3
          if (UNEXPECTED(EG(exception) != NULL)) {
54451
0
            if (IS_CV != IS_CONST) {
54452
54453
0
            }
54454
0
            HANDLE_EXCEPTION();
54455
0
          }
54456
3
        }
54457
3
        if (IS_CV == IS_CONST) {
54458
0
          function_name = EX_VAR(opline->op2.var);
54459
0
        }
54460
3
        zend_invalid_method_call(object, function_name);
54461
54462
54463
3
        HANDLE_EXCEPTION();
54464
3
      }
54465
274
    } while (0);
54466
274
  }
54467
54468
271
  called_scope = obj->ce;
54469
54470
271
  if (IS_CV == IS_CONST &&
54471
271
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
54472
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
54473
271
  } else {
54474
271
    zend_object *orig_obj = obj;
54475
54476
271
    if (IS_CV == IS_CONST) {
54477
0
      function_name = EX_VAR(opline->op2.var);
54478
0
    }
54479
54480
    /* First, locate the function. */
54481
271
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
54482
271
    if (UNEXPECTED(fbc == NULL)) {
54483
10
      if (EXPECTED(!EG(exception))) {
54484
10
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
54485
10
      }
54486
54487
10
      if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
54488
0
        zend_objects_store_del(orig_obj);
54489
0
      }
54490
10
      HANDLE_EXCEPTION();
54491
10
    }
54492
261
    if (IS_CV == IS_CONST &&
54493
261
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
54494
261
        EXPECTED(obj == orig_obj)) {
54495
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
54496
0
    }
54497
261
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
54498
0
      GC_ADDREF(obj); /* For $this pointer */
54499
0
      if (GC_DELREF(orig_obj) == 0) {
54500
0
        zend_objects_store_del(orig_obj);
54501
0
      }
54502
0
    }
54503
261
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
54504
111
      init_func_run_time_cache(&fbc->op_array);
54505
111
    }
54506
261
  }
54507
54508
261
  if (IS_CV != IS_CONST) {
54509
54510
261
  }
54511
54512
261
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
54513
261
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
54514
0
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
54515
0
      zend_objects_store_del(obj);
54516
0
      if (UNEXPECTED(EG(exception))) {
54517
0
        HANDLE_EXCEPTION();
54518
0
      }
54519
0
    }
54520
    /* call static method */
54521
0
    obj = (zend_object*)called_scope;
54522
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
54523
261
  } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
54524
261
    if (IS_CV == IS_CV) {
54525
261
      GC_ADDREF(obj); /* For $this pointer */
54526
261
    }
54527
    /* CV may be changed indirectly (e.g. when it's a reference) */
54528
261
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
54529
261
  }
54530
54531
261
  call = zend_vm_stack_push_call_frame(call_info,
54532
261
    fbc, opline->extended_value, obj);
54533
261
  call->prev_execute_data = EX(call);
54534
261
  EX(call) = call;
54535
54536
261
  ZEND_VM_NEXT_OPCODE();
54537
261
}
54538
54539
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54540
0
{
54541
0
  USE_OPLINE
54542
0
  zval *expr_ptr, new_expr;
54543
54544
0
  SAVE_OPLINE();
54545
0
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
54546
0
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
54547
0
    expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
54548
0
    if (Z_ISREF_P(expr_ptr)) {
54549
0
      Z_ADDREF_P(expr_ptr);
54550
0
    } else {
54551
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
54552
0
    }
54553
54554
0
  } else {
54555
0
    expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54556
0
    if (IS_CV == IS_TMP_VAR) {
54557
      /* pass */
54558
0
    } else if (IS_CV == IS_CONST) {
54559
0
      Z_TRY_ADDREF_P(expr_ptr);
54560
0
    } else if (IS_CV == IS_CV) {
54561
0
      ZVAL_DEREF(expr_ptr);
54562
0
      Z_TRY_ADDREF_P(expr_ptr);
54563
0
    } else /* if (IS_CV == IS_VAR) */ {
54564
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
54565
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
54566
54567
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
54568
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
54569
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
54570
0
          expr_ptr = &new_expr;
54571
0
          efree_size(ref, sizeof(zend_reference));
54572
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
54573
0
          Z_ADDREF_P(expr_ptr);
54574
0
        }
54575
0
      }
54576
0
    }
54577
0
  }
54578
54579
0
  if (IS_CV != IS_UNUSED) {
54580
0
    zval *offset = EX_VAR(opline->op2.var);
54581
0
    zend_string *str;
54582
0
    zend_ulong hval;
54583
54584
0
add_again:
54585
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54586
0
      str = Z_STR_P(offset);
54587
0
      if (IS_CV != IS_CONST) {
54588
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
54589
0
          goto num_index;
54590
0
        }
54591
0
      }
54592
0
str_index:
54593
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
54594
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54595
0
      hval = Z_LVAL_P(offset);
54596
0
num_index:
54597
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
54598
0
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
54599
0
      offset = Z_REFVAL_P(offset);
54600
0
      goto add_again;
54601
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
54602
0
      str = ZSTR_EMPTY_ALLOC();
54603
0
      goto str_index;
54604
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
54605
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
54606
0
      goto num_index;
54607
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
54608
0
      hval = 0;
54609
0
      goto num_index;
54610
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
54611
0
      hval = 1;
54612
0
      goto num_index;
54613
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
54614
0
      zend_use_resource_as_offset(offset);
54615
0
      hval = Z_RES_HANDLE_P(offset);
54616
0
      goto num_index;
54617
0
    } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
54618
0
      ZVAL_UNDEFINED_OP2();
54619
0
      str = ZSTR_EMPTY_ALLOC();
54620
0
      goto str_index;
54621
0
    } else {
54622
0
      zend_illegal_array_offset_access(offset);
54623
0
      zval_ptr_dtor_nogc(expr_ptr);
54624
0
    }
54625
54626
0
  } else {
54627
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
54628
0
      zend_cannot_add_element();
54629
0
      zval_ptr_dtor_nogc(expr_ptr);
54630
0
    }
54631
0
  }
54632
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54633
0
}
54634
54635
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54636
0
{
54637
0
  zval *array;
54638
0
  uint32_t size;
54639
0
  USE_OPLINE
54640
54641
0
  SAVE_OPLINE();
54642
0
  array = EX_VAR(opline->result.var);
54643
0
  if (IS_CV != IS_UNUSED) {
54644
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
54645
0
    ZVAL_ARR(array, zend_new_array(size));
54646
    /* Explicitly initialize array as not-packed if flag is set */
54647
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
54648
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
54649
0
    }
54650
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
54651
0
  } else {
54652
0
    ZVAL_ARR(array, zend_new_array(0));
54653
0
    ZEND_VM_NEXT_OPCODE();
54654
0
  }
54655
0
}
54656
54657
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54658
1.10k
{
54659
1.10k
  USE_OPLINE
54660
1.10k
  zval *container;
54661
1.10k
  zval *offset;
54662
1.10k
  zend_ulong hval;
54663
1.10k
  zend_string *key;
54664
54665
1.10k
  SAVE_OPLINE();
54666
1.10k
  container = EX_VAR(opline->op1.var);
54667
1.10k
  offset = EX_VAR(opline->op2.var);
54668
54669
1.10k
  do {
54670
1.10k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54671
97
      HashTable *ht;
54672
54673
643
unset_dim_array:
54674
643
      SEPARATE_ARRAY(container);
54675
643
      ht = Z_ARRVAL_P(container);
54676
643
offset_again:
54677
643
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54678
184
        key = Z_STR_P(offset);
54679
184
        if (IS_CV != IS_CONST) {
54680
184
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
54681
11
            goto num_index_dim;
54682
11
          }
54683
184
        }
54684
187
str_index_dim:
54685
187
        ZEND_ASSERT(ht != &EG(symbol_table));
54686
187
        zend_hash_del(ht, key);
54687
459
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54688
435
        hval = Z_LVAL_P(offset);
54689
456
num_index_dim:
54690
456
        zend_hash_index_del(ht, hval);
54691
456
      } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
54692
0
        offset = Z_REFVAL_P(offset);
54693
0
        goto offset_again;
54694
24
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
54695
10
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
54696
10
        goto num_index_dim;
54697
14
      } else if (Z_TYPE_P(offset) == IS_NULL) {
54698
12
        key = ZSTR_EMPTY_ALLOC();
54699
12
        goto str_index_dim;
54700
12
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
54701
0
        hval = 0;
54702
0
        goto num_index_dim;
54703
2
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
54704
0
        hval = 1;
54705
0
        goto num_index_dim;
54706
2
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
54707
0
        zend_use_resource_as_offset(offset);
54708
0
        hval = Z_RES_HANDLE_P(offset);
54709
0
        goto num_index_dim;
54710
2
      } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
54711
2
        ZVAL_UNDEFINED_OP2();
54712
2
        key = ZSTR_EMPTY_ALLOC();
54713
2
        goto str_index_dim;
54714
2
      } else {
54715
0
        zend_illegal_array_offset_unset(offset);
54716
0
      }
54717
643
      break;
54718
1.01k
    } else if (Z_ISREF_P(container)) {
54719
548
      container = Z_REFVAL_P(container);
54720
548
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54721
546
        goto unset_dim_array;
54722
546
      }
54723
548
    }
54724
466
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
54725
436
      container = ZVAL_UNDEFINED_OP1();
54726
436
    }
54727
466
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
54728
250
      offset = ZVAL_UNDEFINED_OP2();
54729
250
    }
54730
466
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
54731
28
      if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
54732
0
        offset++;
54733
0
      }
54734
28
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
54735
438
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
54736
2
      zend_throw_error(NULL, "Cannot unset string offsets");
54737
436
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
54738
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
54739
436
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
54740
0
      zend_false_to_array_deprecated();
54741
0
    }
54742
466
  } while (0);
54743
54744
54745
1.10k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54746
1.10k
}
54747
54748
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54749
12
{
54750
12
  USE_OPLINE
54751
12
  zval *container;
54752
12
  zval *offset;
54753
12
  zend_string *name, *tmp_name;
54754
54755
12
  SAVE_OPLINE();
54756
12
  container = EX_VAR(opline->op1.var);
54757
12
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54758
54759
12
  do {
54760
12
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
54761
0
      if (Z_ISREF_P(container)) {
54762
0
        container = Z_REFVAL_P(container);
54763
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
54764
0
          if (IS_CV == IS_CV
54765
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
54766
0
            ZVAL_UNDEFINED_OP1();
54767
0
          }
54768
0
          break;
54769
0
        }
54770
0
      } else {
54771
0
        break;
54772
0
      }
54773
0
    }
54774
12
    if (IS_CV == IS_CONST) {
54775
0
      name = Z_STR_P(offset);
54776
12
    } else {
54777
12
      name = zval_try_get_tmp_string(offset, &tmp_name);
54778
12
      if (UNEXPECTED(!name)) {
54779
0
        break;
54780
0
      }
54781
12
    }
54782
12
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
54783
12
    if (IS_CV != IS_CONST) {
54784
12
      zend_tmp_string_release(tmp_name);
54785
12
    }
54786
12
  } while (0);
54787
54788
54789
12
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54790
12
}
54791
54792
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54793
1.31k
{
54794
1.31k
  USE_OPLINE
54795
1.31k
  zval *container;
54796
1.31k
  bool result;
54797
1.31k
  zend_ulong hval;
54798
1.31k
  zval *offset;
54799
54800
1.31k
  SAVE_OPLINE();
54801
1.31k
  container = EX_VAR(opline->op1.var);
54802
1.31k
  offset = EX_VAR(opline->op2.var);
54803
54804
1.31k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54805
816
    HashTable *ht;
54806
816
    zval *value;
54807
816
    zend_string *str;
54808
54809
1.03k
isset_dim_obj_array:
54810
1.03k
    ht = Z_ARRVAL_P(container);
54811
1.03k
isset_again:
54812
1.03k
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54813
180
      str = Z_STR_P(offset);
54814
180
      if (IS_CV != IS_CONST) {
54815
180
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
54816
0
          goto num_index_prop;
54817
0
        }
54818
180
      }
54819
180
      value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
54820
850
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54821
829
      hval = Z_LVAL_P(offset);
54822
829
num_index_prop:
54823
829
      value = zend_hash_index_find(ht, hval);
54824
829
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
54825
0
      offset = Z_REFVAL_P(offset);
54826
0
      goto isset_again;
54827
21
    } else {
54828
21
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
54829
21
      if (UNEXPECTED(EG(exception))) {
54830
5
        result = 0;
54831
5
        goto isset_dim_obj_exit;
54832
5
      }
54833
21
    }
54834
54835
1.02k
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
54836
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
54837
1.02k
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
54838
1.02k
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
54839
54840
1.02k
      if (IS_CV & (IS_CONST|IS_CV)) {
54841
        /* avoid exception check */
54842
54843
1.02k
        ZEND_VM_SMART_BRANCH(result, 0);
54844
1.02k
      }
54845
1.02k
    } else {
54846
0
      result = (value == NULL || !i_zend_is_true(value));
54847
0
    }
54848
0
    goto isset_dim_obj_exit;
54849
1.02k
  } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
54850
214
    container = Z_REFVAL_P(container);
54851
214
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54852
214
      goto isset_dim_obj_array;
54853
214
    }
54854
214
  }
54855
54856
289
  if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
54857
0
    offset++;
54858
0
  }
54859
289
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
54860
158
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
54861
158
  } else {
54862
131
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
54863
131
  }
54864
54865
294
isset_dim_obj_exit:
54866
54867
54868
294
  ZEND_VM_SMART_BRANCH(result, 1);
54869
294
}
54870
54871
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54872
23
{
54873
23
  USE_OPLINE
54874
23
  zval *container;
54875
23
  int result;
54876
23
  zval *offset;
54877
23
  zend_string *name, *tmp_name;
54878
54879
23
  SAVE_OPLINE();
54880
23
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
54881
23
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54882
54883
23
  if (IS_CV == IS_CONST ||
54884
23
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
54885
5
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
54886
5
      container = Z_REFVAL_P(container);
54887
5
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
54888
0
        result = (opline->extended_value & ZEND_ISEMPTY);
54889
0
        goto isset_object_finish;
54890
0
      }
54891
5
    } else {
54892
0
      result = (opline->extended_value & ZEND_ISEMPTY);
54893
0
      goto isset_object_finish;
54894
0
    }
54895
5
  }
54896
54897
23
  if (IS_CV == IS_CONST) {
54898
0
    name = Z_STR_P(offset);
54899
23
  } else {
54900
23
    name = zval_try_get_tmp_string(offset, &tmp_name);
54901
23
    if (UNEXPECTED(!name)) {
54902
0
      result = 0;
54903
0
      goto isset_object_finish;
54904
0
    }
54905
23
  }
54906
54907
23
  result =
54908
23
    (opline->extended_value & ZEND_ISEMPTY) ^
54909
23
    Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL));
54910
54911
23
  if (IS_CV != IS_CONST) {
54912
23
    zend_tmp_string_release(tmp_name);
54913
23
  }
54914
54915
23
isset_object_finish:
54916
54917
54918
23
  ZEND_VM_SMART_BRANCH(result, 1);
54919
23
}
54920
54921
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54922
0
{
54923
0
  USE_OPLINE
54924
54925
0
  zval *key, *subject;
54926
0
  HashTable *ht;
54927
0
  bool result;
54928
54929
0
  SAVE_OPLINE();
54930
54931
0
  key = EX_VAR(opline->op1.var);
54932
0
  subject = EX_VAR(opline->op2.var);
54933
54934
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
54935
0
array_key_exists_array:
54936
0
    ht = Z_ARRVAL_P(subject);
54937
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
54938
0
  } else {
54939
0
    if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
54940
0
      subject = Z_REFVAL_P(subject);
54941
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
54942
0
        goto array_key_exists_array;
54943
0
      }
54944
0
    }
54945
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
54946
0
    result = 0;
54947
0
  }
54948
54949
54950
0
  ZEND_VM_SMART_BRANCH(result, 1);
54951
0
}
54952
54953
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54954
101
{
54955
101
  USE_OPLINE
54956
54957
101
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
54958
54959
101
  SAVE_OPLINE();
54960
101
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
54961
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
54962
0
  }
54963
54964
  /* Destroy the previously yielded value */
54965
101
  zval_ptr_dtor(&generator->value);
54966
54967
  /* Destroy the previously yielded key */
54968
101
  zval_ptr_dtor(&generator->key);
54969
54970
  /* Set the new yielded value */
54971
101
  if (IS_CV != IS_UNUSED) {
54972
101
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
54973
      /* Constants and temporary variables aren't yieldable by reference,
54974
       * but we still allow them with a notice. */
54975
101
      if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
54976
0
        zval *value;
54977
54978
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
54979
54980
0
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54981
0
        ZVAL_COPY_VALUE(&generator->value, value);
54982
0
        if (IS_CV == IS_CONST) {
54983
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
54984
0
            Z_ADDREF(generator->value);
54985
0
          }
54986
0
        }
54987
101
      } else {
54988
101
        zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
54989
54990
        /* If a function call result is yielded and the function did
54991
         * not return by reference we throw a notice. */
54992
101
        do {
54993
101
          if (IS_CV == IS_VAR) {
54994
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
54995
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
54996
0
             && !Z_ISREF_P(value_ptr)) {
54997
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
54998
0
              ZVAL_COPY(&generator->value, value_ptr);
54999
0
              break;
55000
0
            }
55001
0
          }
55002
101
          if (Z_ISREF_P(value_ptr)) {
55003
93
            Z_ADDREF_P(value_ptr);
55004
93
          } else {
55005
8
            ZVAL_MAKE_REF_EX(value_ptr, 2);
55006
8
          }
55007
101
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
55008
101
        } while (0);
55009
55010
101
      }
55011
101
    } else {
55012
0
      zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
55013
55014
      /* Consts, temporary variables and references need copying */
55015
0
      if (IS_CV == IS_CONST) {
55016
0
        ZVAL_COPY_VALUE(&generator->value, value);
55017
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
55018
0
          Z_ADDREF(generator->value);
55019
0
        }
55020
0
      } else if (IS_CV == IS_TMP_VAR) {
55021
0
        ZVAL_COPY_VALUE(&generator->value, value);
55022
0
      } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
55023
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
55024
55025
0
      } else {
55026
0
        ZVAL_COPY_VALUE(&generator->value, value);
55027
0
        if (IS_CV == IS_CV) {
55028
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
55029
0
        }
55030
0
      }
55031
0
    }
55032
101
  } else {
55033
    /* If no value was specified yield null */
55034
0
    ZVAL_NULL(&generator->value);
55035
0
  }
55036
55037
  /* Set the new yielded key */
55038
101
  if (IS_CV != IS_UNUSED) {
55039
101
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
55040
101
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
55041
0
      key = Z_REFVAL_P(key);
55042
0
    }
55043
101
    ZVAL_COPY(&generator->key, key);
55044
55045
101
    if (Z_TYPE(generator->key) == IS_LONG
55046
101
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
55047
101
    ) {
55048
85
      generator->largest_used_integer_key = Z_LVAL(generator->key);
55049
85
    }
55050
101
  } else {
55051
    /* If no key was specified we use auto-increment keys */
55052
0
    generator->largest_used_integer_key++;
55053
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
55054
0
  }
55055
55056
101
  if (RETURN_VALUE_USED(opline)) {
55057
    /* If the return value of yield is used set the send
55058
     * target and initialize it to NULL */
55059
2
    generator->send_target = EX_VAR(opline->result.var);
55060
2
    ZVAL_NULL(generator->send_target);
55061
99
  } else {
55062
99
    generator->send_target = NULL;
55063
99
  }
55064
55065
  /* The GOTO VM uses a local opline variable. We need to set the opline
55066
   * variable in execute_data so we don't resume at an old position. */
55067
101
  SAVE_OPLINE();
55068
55069
101
  ZEND_VM_RETURN();
55070
101
}
55071
55072
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
55073
77
{
55074
  /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
55075
  /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
55076
  /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
55077
77
  USE_OPLINE
55078
77
  zval *op1, *op2;
55079
77
  bool result;
55080
55081
77
  op1 = EX_VAR(opline->op1.var);
55082
77
  op2 = EX_VAR(opline->op2.var);
55083
77
  result = fast_is_identical_function(op1, op2);
55084
  /* Free is a no-op for const/cv */
55085
77
  ZEND_VM_SMART_BRANCH(result, 0);
55086
77
}
55087
55088
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
55089
0
{
55090
0
  USE_OPLINE
55091
0
  zval *op1, *op2;
55092
0
  bool result;
55093
55094
0
  op1 = EX_VAR(opline->op1.var);
55095
0
  op2 = EX_VAR(opline->op2.var);
55096
0
  result = fast_is_identical_function(op1, op2);
55097
  /* Free is a no-op for const/cv */
55098
0
  ZEND_VM_SMART_BRANCH(!result, 0);
55099
0
}
55100
55101
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
55102
0
{
55103
0
  USE_OPLINE
55104
55105
0
  SAVE_OPLINE();
55106
0
  zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);
55107
0
  ZEND_VM_NEXT_OPCODE(); /* Never reached */
55108
0
}
55109
55110
55111
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
55112
# undef ZEND_VM_TAIL_CALL
55113
# undef ZEND_VM_CONTINUE
55114
# undef ZEND_VM_RETURN
55115
55116
# define ZEND_VM_TAIL_CALL(call) call; ZEND_VM_CONTINUE()
55117
# define ZEND_VM_CONTINUE()      HYBRID_NEXT()
55118
# define ZEND_VM_RETURN()        goto HYBRID_HALT_LABEL
55119
#endif
55120
55121
55122
#if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
55123
# pragma GCC push_options
55124
# pragma GCC optimize("no-gcse")
55125
# pragma GCC optimize("no-ivopts")
55126
#endif
55127
#ifdef _WIN64
55128
/* See save_xmm_x86_64_ms_masm.asm */
55129
void execute_ex_real(zend_execute_data *ex)
55130
#else
55131
ZEND_API void execute_ex(zend_execute_data *ex)
55132
#endif
55133
83.1k
{
55134
83.1k
  DCL_OPLINE
55135
55136
#if defined(__GNUC__) && defined(__aarch64__)
55137
  __asm__ __volatile__ (""::: "v8","v9","v10","v11","v12","v13","v14","v15");
55138
#endif
55139
55140
#if defined(ZEND_VM_IP_GLOBAL_REG) || defined(ZEND_VM_FP_GLOBAL_REG)
55141
  struct {
55142
#ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
55143
    char hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];
55144
#endif
55145
#ifdef ZEND_VM_IP_GLOBAL_REG
55146
    const zend_op *orig_opline;
55147
#endif
55148
#ifdef ZEND_VM_FP_GLOBAL_REG
55149
    zend_execute_data *orig_execute_data;
55150
#endif
55151
  } vm_stack_data;
55152
#endif
55153
#ifdef ZEND_VM_IP_GLOBAL_REG
55154
  vm_stack_data.orig_opline = opline;
55155
#endif
55156
#ifdef ZEND_VM_FP_GLOBAL_REG
55157
  vm_stack_data.orig_execute_data = execute_data;
55158
  execute_data = ex;
55159
#else
55160
83.1k
  zend_execute_data *execute_data = ex;
55161
83.1k
#endif
55162
55163
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
55164
  if (UNEXPECTED(execute_data == NULL)) {
55165
    static const void * const labels[] = {
55166
      (void*)&&ZEND_NOP_SPEC_LABEL,
55167
      (void*)&&ZEND_ADD_SPEC_CONST_CONST_LABEL,
55168
      (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55169
      (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55170
      (void*)&&ZEND_NULL_LABEL,
55171
      (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55172
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55173
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55174
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55175
      (void*)&&ZEND_NULL_LABEL,
55176
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55177
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55178
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55179
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55180
      (void*)&&ZEND_NULL_LABEL,
55181
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55182
      (void*)&&ZEND_NULL_LABEL,
55183
      (void*)&&ZEND_NULL_LABEL,
55184
      (void*)&&ZEND_NULL_LABEL,
55185
      (void*)&&ZEND_NULL_LABEL,
55186
      (void*)&&ZEND_NULL_LABEL,
55187
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55188
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55189
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55190
      (void*)&&ZEND_NULL_LABEL,
55191
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55192
      (void*)&&ZEND_SUB_SPEC_CONST_CONST_LABEL,
55193
      (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55194
      (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55195
      (void*)&&ZEND_NULL_LABEL,
55196
      (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55197
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55198
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55199
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55200
      (void*)&&ZEND_NULL_LABEL,
55201
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55202
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55203
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55204
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55205
      (void*)&&ZEND_NULL_LABEL,
55206
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55207
      (void*)&&ZEND_NULL_LABEL,
55208
      (void*)&&ZEND_NULL_LABEL,
55209
      (void*)&&ZEND_NULL_LABEL,
55210
      (void*)&&ZEND_NULL_LABEL,
55211
      (void*)&&ZEND_NULL_LABEL,
55212
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55213
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55214
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55215
      (void*)&&ZEND_NULL_LABEL,
55216
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55217
      (void*)&&ZEND_MUL_SPEC_CONST_CONST_LABEL,
55218
      (void*)&&ZEND_NULL_LABEL,
55219
      (void*)&&ZEND_NULL_LABEL,
55220
      (void*)&&ZEND_NULL_LABEL,
55221
      (void*)&&ZEND_NULL_LABEL,
55222
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55223
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55224
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55225
      (void*)&&ZEND_NULL_LABEL,
55226
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55227
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55228
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55229
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55230
      (void*)&&ZEND_NULL_LABEL,
55231
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55232
      (void*)&&ZEND_NULL_LABEL,
55233
      (void*)&&ZEND_NULL_LABEL,
55234
      (void*)&&ZEND_NULL_LABEL,
55235
      (void*)&&ZEND_NULL_LABEL,
55236
      (void*)&&ZEND_NULL_LABEL,
55237
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55238
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55239
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55240
      (void*)&&ZEND_NULL_LABEL,
55241
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55242
      (void*)&&ZEND_DIV_SPEC_CONST_CONST_LABEL,
55243
      (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
55244
      (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
55245
      (void*)&&ZEND_NULL_LABEL,
55246
      (void*)&&ZEND_DIV_SPEC_CONST_CV_LABEL,
55247
      (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
55248
      (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55249
      (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55250
      (void*)&&ZEND_NULL_LABEL,
55251
      (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
55252
      (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
55253
      (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55254
      (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55255
      (void*)&&ZEND_NULL_LABEL,
55256
      (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
55257
      (void*)&&ZEND_NULL_LABEL,
55258
      (void*)&&ZEND_NULL_LABEL,
55259
      (void*)&&ZEND_NULL_LABEL,
55260
      (void*)&&ZEND_NULL_LABEL,
55261
      (void*)&&ZEND_NULL_LABEL,
55262
      (void*)&&ZEND_DIV_SPEC_CV_CONST_LABEL,
55263
      (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
55264
      (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
55265
      (void*)&&ZEND_NULL_LABEL,
55266
      (void*)&&ZEND_DIV_SPEC_CV_CV_LABEL,
55267
      (void*)&&ZEND_MOD_SPEC_CONST_CONST_LABEL,
55268
      (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55269
      (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55270
      (void*)&&ZEND_NULL_LABEL,
55271
      (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55272
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55273
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55274
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55275
      (void*)&&ZEND_NULL_LABEL,
55276
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55277
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55278
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55279
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55280
      (void*)&&ZEND_NULL_LABEL,
55281
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55282
      (void*)&&ZEND_NULL_LABEL,
55283
      (void*)&&ZEND_NULL_LABEL,
55284
      (void*)&&ZEND_NULL_LABEL,
55285
      (void*)&&ZEND_NULL_LABEL,
55286
      (void*)&&ZEND_NULL_LABEL,
55287
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55288
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55289
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55290
      (void*)&&ZEND_NULL_LABEL,
55291
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55292
      (void*)&&ZEND_SL_SPEC_CONST_CONST_LABEL,
55293
      (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55294
      (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55295
      (void*)&&ZEND_NULL_LABEL,
55296
      (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55297
      (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55298
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55299
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55300
      (void*)&&ZEND_NULL_LABEL,
55301
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55302
      (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55303
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55304
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55305
      (void*)&&ZEND_NULL_LABEL,
55306
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55307
      (void*)&&ZEND_NULL_LABEL,
55308
      (void*)&&ZEND_NULL_LABEL,
55309
      (void*)&&ZEND_NULL_LABEL,
55310
      (void*)&&ZEND_NULL_LABEL,
55311
      (void*)&&ZEND_NULL_LABEL,
55312
      (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55313
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55314
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55315
      (void*)&&ZEND_NULL_LABEL,
55316
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55317
      (void*)&&ZEND_SR_SPEC_CONST_CONST_LABEL,
55318
      (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55319
      (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55320
      (void*)&&ZEND_NULL_LABEL,
55321
      (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55322
      (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55323
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55324
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55325
      (void*)&&ZEND_NULL_LABEL,
55326
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55327
      (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55328
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55329
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55330
      (void*)&&ZEND_NULL_LABEL,
55331
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55332
      (void*)&&ZEND_NULL_LABEL,
55333
      (void*)&&ZEND_NULL_LABEL,
55334
      (void*)&&ZEND_NULL_LABEL,
55335
      (void*)&&ZEND_NULL_LABEL,
55336
      (void*)&&ZEND_NULL_LABEL,
55337
      (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55338
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55339
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55340
      (void*)&&ZEND_NULL_LABEL,
55341
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55342
      (void*)&&ZEND_NULL_LABEL,
55343
      (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
55344
      (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
55345
      (void*)&&ZEND_NULL_LABEL,
55346
      (void*)&&ZEND_CONCAT_SPEC_CONST_CV_LABEL,
55347
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
55348
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55349
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55350
      (void*)&&ZEND_NULL_LABEL,
55351
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
55352
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
55353
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55354
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55355
      (void*)&&ZEND_NULL_LABEL,
55356
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
55357
      (void*)&&ZEND_NULL_LABEL,
55358
      (void*)&&ZEND_NULL_LABEL,
55359
      (void*)&&ZEND_NULL_LABEL,
55360
      (void*)&&ZEND_NULL_LABEL,
55361
      (void*)&&ZEND_NULL_LABEL,
55362
      (void*)&&ZEND_CONCAT_SPEC_CV_CONST_LABEL,
55363
      (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
55364
      (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
55365
      (void*)&&ZEND_NULL_LABEL,
55366
      (void*)&&ZEND_CONCAT_SPEC_CV_CV_LABEL,
55367
      (void*)&&ZEND_BW_OR_SPEC_CONST_CONST_LABEL,
55368
      (void*)&&ZEND_NULL_LABEL,
55369
      (void*)&&ZEND_NULL_LABEL,
55370
      (void*)&&ZEND_NULL_LABEL,
55371
      (void*)&&ZEND_NULL_LABEL,
55372
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55373
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55374
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55375
      (void*)&&ZEND_NULL_LABEL,
55376
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55377
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55378
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55379
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55380
      (void*)&&ZEND_NULL_LABEL,
55381
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55382
      (void*)&&ZEND_NULL_LABEL,
55383
      (void*)&&ZEND_NULL_LABEL,
55384
      (void*)&&ZEND_NULL_LABEL,
55385
      (void*)&&ZEND_NULL_LABEL,
55386
      (void*)&&ZEND_NULL_LABEL,
55387
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55388
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55389
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55390
      (void*)&&ZEND_NULL_LABEL,
55391
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55392
      (void*)&&ZEND_BW_AND_SPEC_CONST_CONST_LABEL,
55393
      (void*)&&ZEND_NULL_LABEL,
55394
      (void*)&&ZEND_NULL_LABEL,
55395
      (void*)&&ZEND_NULL_LABEL,
55396
      (void*)&&ZEND_NULL_LABEL,
55397
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55398
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55399
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55400
      (void*)&&ZEND_NULL_LABEL,
55401
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55402
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55403
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55404
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55405
      (void*)&&ZEND_NULL_LABEL,
55406
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55407
      (void*)&&ZEND_NULL_LABEL,
55408
      (void*)&&ZEND_NULL_LABEL,
55409
      (void*)&&ZEND_NULL_LABEL,
55410
      (void*)&&ZEND_NULL_LABEL,
55411
      (void*)&&ZEND_NULL_LABEL,
55412
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55413
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55414
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55415
      (void*)&&ZEND_NULL_LABEL,
55416
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55417
      (void*)&&ZEND_BW_XOR_SPEC_CONST_CONST_LABEL,
55418
      (void*)&&ZEND_NULL_LABEL,
55419
      (void*)&&ZEND_NULL_LABEL,
55420
      (void*)&&ZEND_NULL_LABEL,
55421
      (void*)&&ZEND_NULL_LABEL,
55422
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55423
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55424
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55425
      (void*)&&ZEND_NULL_LABEL,
55426
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55427
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55428
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55429
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55430
      (void*)&&ZEND_NULL_LABEL,
55431
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55432
      (void*)&&ZEND_NULL_LABEL,
55433
      (void*)&&ZEND_NULL_LABEL,
55434
      (void*)&&ZEND_NULL_LABEL,
55435
      (void*)&&ZEND_NULL_LABEL,
55436
      (void*)&&ZEND_NULL_LABEL,
55437
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55438
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55439
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55440
      (void*)&&ZEND_NULL_LABEL,
55441
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55442
      (void*)&&ZEND_POW_SPEC_CONST_CONST_LABEL,
55443
      (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
55444
      (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
55445
      (void*)&&ZEND_NULL_LABEL,
55446
      (void*)&&ZEND_POW_SPEC_CONST_CV_LABEL,
55447
      (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
55448
      (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55449
      (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55450
      (void*)&&ZEND_NULL_LABEL,
55451
      (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
55452
      (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
55453
      (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55454
      (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55455
      (void*)&&ZEND_NULL_LABEL,
55456
      (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
55457
      (void*)&&ZEND_NULL_LABEL,
55458
      (void*)&&ZEND_NULL_LABEL,
55459
      (void*)&&ZEND_NULL_LABEL,
55460
      (void*)&&ZEND_NULL_LABEL,
55461
      (void*)&&ZEND_NULL_LABEL,
55462
      (void*)&&ZEND_POW_SPEC_CV_CONST_LABEL,
55463
      (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
55464
      (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
55465
      (void*)&&ZEND_NULL_LABEL,
55466
      (void*)&&ZEND_POW_SPEC_CV_CV_LABEL,
55467
      (void*)&&ZEND_BW_NOT_SPEC_CONST_LABEL,
55468
      (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55469
      (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55470
      (void*)&&ZEND_NULL_LABEL,
55471
      (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55472
      (void*)&&ZEND_BOOL_NOT_SPEC_CONST_LABEL,
55473
      (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
55474
      (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
55475
      (void*)&&ZEND_NULL_LABEL,
55476
      (void*)&&ZEND_BOOL_NOT_SPEC_CV_LABEL,
55477
      (void*)&&ZEND_BOOL_XOR_SPEC_CONST_CONST_LABEL,
55478
      (void*)&&ZEND_NULL_LABEL,
55479
      (void*)&&ZEND_NULL_LABEL,
55480
      (void*)&&ZEND_NULL_LABEL,
55481
      (void*)&&ZEND_NULL_LABEL,
55482
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
55483
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55484
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55485
      (void*)&&ZEND_NULL_LABEL,
55486
      (void*)&&ZEND_NULL_LABEL,
55487
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
55488
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55489
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55490
      (void*)&&ZEND_NULL_LABEL,
55491
      (void*)&&ZEND_NULL_LABEL,
55492
      (void*)&&ZEND_NULL_LABEL,
55493
      (void*)&&ZEND_NULL_LABEL,
55494
      (void*)&&ZEND_NULL_LABEL,
55495
      (void*)&&ZEND_NULL_LABEL,
55496
      (void*)&&ZEND_NULL_LABEL,
55497
      (void*)&&ZEND_BOOL_XOR_SPEC_CV_CONST_LABEL,
55498
      (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
55499
      (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
55500
      (void*)&&ZEND_NULL_LABEL,
55501
      (void*)&&ZEND_BOOL_XOR_SPEC_CV_CV_LABEL,
55502
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CONST_CONST_LABEL,
55503
      (void*)&&ZEND_NULL_LABEL,
55504
      (void*)&&ZEND_NULL_LABEL,
55505
      (void*)&&ZEND_NULL_LABEL,
55506
      (void*)&&ZEND_NULL_LABEL,
55507
      (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_CONST_LABEL,
55508
      (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_TMP_LABEL,
55509
      (void*)&&ZEND_NULL_LABEL,
55510
      (void*)&&ZEND_NULL_LABEL,
55511
      (void*)&&ZEND_NULL_LABEL,
55512
      (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_CONST_LABEL,
55513
      (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_TMP_LABEL,
55514
      (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_VAR_LABEL,
55515
      (void*)&&ZEND_NULL_LABEL,
55516
      (void*)&&ZEND_NULL_LABEL,
55517
      (void*)&&ZEND_NULL_LABEL,
55518
      (void*)&&ZEND_NULL_LABEL,
55519
      (void*)&&ZEND_NULL_LABEL,
55520
      (void*)&&ZEND_NULL_LABEL,
55521
      (void*)&&ZEND_NULL_LABEL,
55522
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CONST_LABEL,
55523
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_TMP_LABEL,
55524
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_VAR_LABEL,
55525
      (void*)&&ZEND_NULL_LABEL,
55526
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CV_LABEL,
55527
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_LABEL,
55528
      (void*)&&ZEND_NULL_LABEL,
55529
      (void*)&&ZEND_NULL_LABEL,
55530
      (void*)&&ZEND_NULL_LABEL,
55531
      (void*)&&ZEND_NULL_LABEL,
55532
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_LABEL,
55533
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_LABEL,
55534
      (void*)&&ZEND_NULL_LABEL,
55535
      (void*)&&ZEND_NULL_LABEL,
55536
      (void*)&&ZEND_NULL_LABEL,
55537
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_LABEL,
55538
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_LABEL,
55539
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_LABEL,
55540
      (void*)&&ZEND_NULL_LABEL,
55541
      (void*)&&ZEND_NULL_LABEL,
55542
      (void*)&&ZEND_NULL_LABEL,
55543
      (void*)&&ZEND_NULL_LABEL,
55544
      (void*)&&ZEND_NULL_LABEL,
55545
      (void*)&&ZEND_NULL_LABEL,
55546
      (void*)&&ZEND_NULL_LABEL,
55547
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_LABEL,
55548
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_LABEL,
55549
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_LABEL,
55550
      (void*)&&ZEND_NULL_LABEL,
55551
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_LABEL,
55552
      (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55553
      (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55554
      (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55555
      (void*)&&ZEND_NULL_LABEL,
55556
      (void*)&&ZEND_NULL_LABEL,
55557
      (void*)&&ZEND_NULL_LABEL,
55558
      (void*)&&ZEND_NULL_LABEL,
55559
      (void*)&&ZEND_NULL_LABEL,
55560
      (void*)&&ZEND_NULL_LABEL,
55561
      (void*)&&ZEND_NULL_LABEL,
55562
      (void*)&&ZEND_NULL_LABEL,
55563
      (void*)&&ZEND_NULL_LABEL,
55564
      (void*)&&ZEND_NULL_LABEL,
55565
      (void*)&&ZEND_NULL_LABEL,
55566
      (void*)&&ZEND_NULL_LABEL,
55567
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55568
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55569
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55570
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55571
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55572
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55573
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55574
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55575
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55576
      (void*)&&ZEND_NULL_LABEL,
55577
      (void*)&&ZEND_NULL_LABEL,
55578
      (void*)&&ZEND_NULL_LABEL,
55579
      (void*)&&ZEND_NULL_LABEL,
55580
      (void*)&&ZEND_NULL_LABEL,
55581
      (void*)&&ZEND_NULL_LABEL,
55582
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55583
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55584
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55585
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55586
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55587
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55588
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55589
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55590
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55591
      (void*)&&ZEND_NULL_LABEL,
55592
      (void*)&&ZEND_NULL_LABEL,
55593
      (void*)&&ZEND_NULL_LABEL,
55594
      (void*)&&ZEND_NULL_LABEL,
55595
      (void*)&&ZEND_NULL_LABEL,
55596
      (void*)&&ZEND_NULL_LABEL,
55597
      (void*)&&ZEND_NULL_LABEL,
55598
      (void*)&&ZEND_NULL_LABEL,
55599
      (void*)&&ZEND_NULL_LABEL,
55600
      (void*)&&ZEND_NULL_LABEL,
55601
      (void*)&&ZEND_NULL_LABEL,
55602
      (void*)&&ZEND_NULL_LABEL,
55603
      (void*)&&ZEND_NULL_LABEL,
55604
      (void*)&&ZEND_NULL_LABEL,
55605
      (void*)&&ZEND_NULL_LABEL,
55606
      (void*)&&ZEND_NULL_LABEL,
55607
      (void*)&&ZEND_NULL_LABEL,
55608
      (void*)&&ZEND_NULL_LABEL,
55609
      (void*)&&ZEND_NULL_LABEL,
55610
      (void*)&&ZEND_NULL_LABEL,
55611
      (void*)&&ZEND_NULL_LABEL,
55612
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_LABEL,
55613
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
55614
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
55615
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
55616
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55617
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55618
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
55619
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55620
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55621
      (void*)&&ZEND_NULL_LABEL,
55622
      (void*)&&ZEND_NULL_LABEL,
55623
      (void*)&&ZEND_NULL_LABEL,
55624
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_LABEL,
55625
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
55626
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
55627
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55628
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55629
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55630
      (void*)&&ZEND_NULL_LABEL,
55631
      (void*)&&ZEND_NULL_LABEL,
55632
      (void*)&&ZEND_NULL_LABEL,
55633
      (void*)&&ZEND_NULL_LABEL,
55634
      (void*)&&ZEND_NULL_LABEL,
55635
      (void*)&&ZEND_NULL_LABEL,
55636
      (void*)&&ZEND_NULL_LABEL,
55637
      (void*)&&ZEND_NULL_LABEL,
55638
      (void*)&&ZEND_NULL_LABEL,
55639
      (void*)&&ZEND_NULL_LABEL,
55640
      (void*)&&ZEND_NULL_LABEL,
55641
      (void*)&&ZEND_NULL_LABEL,
55642
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55643
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55644
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55645
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55646
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55647
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55648
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55649
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55650
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55651
      (void*)&&ZEND_NULL_LABEL,
55652
      (void*)&&ZEND_NULL_LABEL,
55653
      (void*)&&ZEND_NULL_LABEL,
55654
      (void*)&&ZEND_NULL_LABEL,
55655
      (void*)&&ZEND_NULL_LABEL,
55656
      (void*)&&ZEND_NULL_LABEL,
55657
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55658
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55659
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55660
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55661
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55662
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55663
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55664
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55665
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55666
      (void*)&&ZEND_NULL_LABEL,
55667
      (void*)&&ZEND_NULL_LABEL,
55668
      (void*)&&ZEND_NULL_LABEL,
55669
      (void*)&&ZEND_NULL_LABEL,
55670
      (void*)&&ZEND_NULL_LABEL,
55671
      (void*)&&ZEND_NULL_LABEL,
55672
      (void*)&&ZEND_NULL_LABEL,
55673
      (void*)&&ZEND_NULL_LABEL,
55674
      (void*)&&ZEND_NULL_LABEL,
55675
      (void*)&&ZEND_NULL_LABEL,
55676
      (void*)&&ZEND_NULL_LABEL,
55677
      (void*)&&ZEND_NULL_LABEL,
55678
      (void*)&&ZEND_NULL_LABEL,
55679
      (void*)&&ZEND_NULL_LABEL,
55680
      (void*)&&ZEND_NULL_LABEL,
55681
      (void*)&&ZEND_NULL_LABEL,
55682
      (void*)&&ZEND_NULL_LABEL,
55683
      (void*)&&ZEND_NULL_LABEL,
55684
      (void*)&&ZEND_NULL_LABEL,
55685
      (void*)&&ZEND_NULL_LABEL,
55686
      (void*)&&ZEND_NULL_LABEL,
55687
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_LABEL,
55688
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
55689
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
55690
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
55691
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55692
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55693
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
55694
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55695
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55696
      (void*)&&ZEND_NULL_LABEL,
55697
      (void*)&&ZEND_NULL_LABEL,
55698
      (void*)&&ZEND_NULL_LABEL,
55699
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_LABEL,
55700
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
55701
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
55702
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55703
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55704
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55705
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55706
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55707
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55708
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55709
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55710
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55711
      (void*)&&ZEND_NULL_LABEL,
55712
      (void*)&&ZEND_NULL_LABEL,
55713
      (void*)&&ZEND_NULL_LABEL,
55714
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55715
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55716
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55717
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55718
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55719
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55720
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55721
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55722
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55723
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55724
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55725
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55726
      (void*)&&ZEND_NULL_LABEL,
55727
      (void*)&&ZEND_NULL_LABEL,
55728
      (void*)&&ZEND_NULL_LABEL,
55729
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55730
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55731
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55732
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55733
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55734
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55735
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55736
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55737
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55738
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55739
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55740
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55741
      (void*)&&ZEND_NULL_LABEL,
55742
      (void*)&&ZEND_NULL_LABEL,
55743
      (void*)&&ZEND_NULL_LABEL,
55744
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55745
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55746
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55747
      (void*)&&ZEND_NULL_LABEL,
55748
      (void*)&&ZEND_NULL_LABEL,
55749
      (void*)&&ZEND_NULL_LABEL,
55750
      (void*)&&ZEND_NULL_LABEL,
55751
      (void*)&&ZEND_NULL_LABEL,
55752
      (void*)&&ZEND_NULL_LABEL,
55753
      (void*)&&ZEND_NULL_LABEL,
55754
      (void*)&&ZEND_NULL_LABEL,
55755
      (void*)&&ZEND_NULL_LABEL,
55756
      (void*)&&ZEND_NULL_LABEL,
55757
      (void*)&&ZEND_NULL_LABEL,
55758
      (void*)&&ZEND_NULL_LABEL,
55759
      (void*)&&ZEND_NULL_LABEL,
55760
      (void*)&&ZEND_NULL_LABEL,
55761
      (void*)&&ZEND_NULL_LABEL,
55762
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55763
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55764
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55765
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55766
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55767
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55768
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55769
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55770
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55771
      (void*)&&ZEND_NULL_LABEL,
55772
      (void*)&&ZEND_NULL_LABEL,
55773
      (void*)&&ZEND_NULL_LABEL,
55774
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55775
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55776
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55777
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55778
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55779
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55780
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55781
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55782
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55783
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55784
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55785
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55786
      (void*)&&ZEND_NULL_LABEL,
55787
      (void*)&&ZEND_NULL_LABEL,
55788
      (void*)&&ZEND_NULL_LABEL,
55789
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55790
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55791
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55792
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55793
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55794
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55795
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55796
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55797
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55798
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55799
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55800
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55801
      (void*)&&ZEND_NULL_LABEL,
55802
      (void*)&&ZEND_NULL_LABEL,
55803
      (void*)&&ZEND_NULL_LABEL,
55804
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55805
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55806
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55807
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55808
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55809
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55810
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55811
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55812
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55813
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55814
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55815
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55816
      (void*)&&ZEND_NULL_LABEL,
55817
      (void*)&&ZEND_NULL_LABEL,
55818
      (void*)&&ZEND_NULL_LABEL,
55819
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55820
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55821
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55822
      (void*)&&ZEND_NULL_LABEL,
55823
      (void*)&&ZEND_NULL_LABEL,
55824
      (void*)&&ZEND_NULL_LABEL,
55825
      (void*)&&ZEND_NULL_LABEL,
55826
      (void*)&&ZEND_NULL_LABEL,
55827
      (void*)&&ZEND_NULL_LABEL,
55828
      (void*)&&ZEND_NULL_LABEL,
55829
      (void*)&&ZEND_NULL_LABEL,
55830
      (void*)&&ZEND_NULL_LABEL,
55831
      (void*)&&ZEND_NULL_LABEL,
55832
      (void*)&&ZEND_NULL_LABEL,
55833
      (void*)&&ZEND_NULL_LABEL,
55834
      (void*)&&ZEND_NULL_LABEL,
55835
      (void*)&&ZEND_NULL_LABEL,
55836
      (void*)&&ZEND_NULL_LABEL,
55837
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55838
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55839
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55840
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55841
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55842
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55843
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55844
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55845
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55846
      (void*)&&ZEND_NULL_LABEL,
55847
      (void*)&&ZEND_NULL_LABEL,
55848
      (void*)&&ZEND_NULL_LABEL,
55849
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55850
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55851
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55852
      (void*)&&ZEND_NULL_LABEL,
55853
      (void*)&&ZEND_NULL_LABEL,
55854
      (void*)&&ZEND_NULL_LABEL,
55855
      (void*)&&ZEND_NULL_LABEL,
55856
      (void*)&&ZEND_NULL_LABEL,
55857
      (void*)&&ZEND_NULL_LABEL,
55858
      (void*)&&ZEND_NULL_LABEL,
55859
      (void*)&&ZEND_NULL_LABEL,
55860
      (void*)&&ZEND_NULL_LABEL,
55861
      (void*)&&ZEND_NULL_LABEL,
55862
      (void*)&&ZEND_NULL_LABEL,
55863
      (void*)&&ZEND_NULL_LABEL,
55864
      (void*)&&ZEND_NULL_LABEL,
55865
      (void*)&&ZEND_NULL_LABEL,
55866
      (void*)&&ZEND_NULL_LABEL,
55867
      (void*)&&ZEND_NULL_LABEL,
55868
      (void*)&&ZEND_NULL_LABEL,
55869
      (void*)&&ZEND_NULL_LABEL,
55870
      (void*)&&ZEND_NULL_LABEL,
55871
      (void*)&&ZEND_NULL_LABEL,
55872
      (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_LABEL,
55873
      (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_LABEL,
55874
      (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_LABEL,
55875
      (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_LABEL,
55876
      (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_LABEL,
55877
      (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_LABEL,
55878
      (void*)&&ZEND_NULL_LABEL,
55879
      (void*)&&ZEND_NULL_LABEL,
55880
      (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
55881
      (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_LABEL,
55882
      (void*)&&ZEND_NULL_LABEL,
55883
      (void*)&&ZEND_NULL_LABEL,
55884
      (void*)&&ZEND_NULL_LABEL,
55885
      (void*)&&ZEND_NULL_LABEL,
55886
      (void*)&&ZEND_NULL_LABEL,
55887
      (void*)&&ZEND_NULL_LABEL,
55888
      (void*)&&ZEND_NULL_LABEL,
55889
      (void*)&&ZEND_NULL_LABEL,
55890
      (void*)&&ZEND_NULL_LABEL,
55891
      (void*)&&ZEND_NULL_LABEL,
55892
      (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_LABEL,
55893
      (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_LABEL,
55894
      (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_LABEL,
55895
      (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_LABEL,
55896
      (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_LABEL,
55897
      (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_LABEL,
55898
      (void*)&&ZEND_NULL_LABEL,
55899
      (void*)&&ZEND_NULL_LABEL,
55900
      (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_LABEL,
55901
      (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_LABEL,
55902
      (void*)&&ZEND_NULL_LABEL,
55903
      (void*)&&ZEND_NULL_LABEL,
55904
      (void*)&&ZEND_NULL_LABEL,
55905
      (void*)&&ZEND_NULL_LABEL,
55906
      (void*)&&ZEND_NULL_LABEL,
55907
      (void*)&&ZEND_NULL_LABEL,
55908
      (void*)&&ZEND_NULL_LABEL,
55909
      (void*)&&ZEND_NULL_LABEL,
55910
      (void*)&&ZEND_NULL_LABEL,
55911
      (void*)&&ZEND_NULL_LABEL,
55912
      (void*)&&ZEND_NULL_LABEL,
55913
      (void*)&&ZEND_NULL_LABEL,
55914
      (void*)&&ZEND_NULL_LABEL,
55915
      (void*)&&ZEND_NULL_LABEL,
55916
      (void*)&&ZEND_NULL_LABEL,
55917
      (void*)&&ZEND_NULL_LABEL,
55918
      (void*)&&ZEND_NULL_LABEL,
55919
      (void*)&&ZEND_NULL_LABEL,
55920
      (void*)&&ZEND_NULL_LABEL,
55921
      (void*)&&ZEND_NULL_LABEL,
55922
      (void*)&&ZEND_NULL_LABEL,
55923
      (void*)&&ZEND_NULL_LABEL,
55924
      (void*)&&ZEND_NULL_LABEL,
55925
      (void*)&&ZEND_NULL_LABEL,
55926
      (void*)&&ZEND_NULL_LABEL,
55927
      (void*)&&ZEND_NULL_LABEL,
55928
      (void*)&&ZEND_NULL_LABEL,
55929
      (void*)&&ZEND_NULL_LABEL,
55930
      (void*)&&ZEND_NULL_LABEL,
55931
      (void*)&&ZEND_NULL_LABEL,
55932
      (void*)&&ZEND_NULL_LABEL,
55933
      (void*)&&ZEND_NULL_LABEL,
55934
      (void*)&&ZEND_NULL_LABEL,
55935
      (void*)&&ZEND_NULL_LABEL,
55936
      (void*)&&ZEND_NULL_LABEL,
55937
      (void*)&&ZEND_NULL_LABEL,
55938
      (void*)&&ZEND_NULL_LABEL,
55939
      (void*)&&ZEND_NULL_LABEL,
55940
      (void*)&&ZEND_NULL_LABEL,
55941
      (void*)&&ZEND_NULL_LABEL,
55942
      (void*)&&ZEND_NULL_LABEL,
55943
      (void*)&&ZEND_NULL_LABEL,
55944
      (void*)&&ZEND_NULL_LABEL,
55945
      (void*)&&ZEND_NULL_LABEL,
55946
      (void*)&&ZEND_NULL_LABEL,
55947
      (void*)&&ZEND_NULL_LABEL,
55948
      (void*)&&ZEND_NULL_LABEL,
55949
      (void*)&&ZEND_NULL_LABEL,
55950
      (void*)&&ZEND_NULL_LABEL,
55951
      (void*)&&ZEND_NULL_LABEL,
55952
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
55953
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
55954
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
55955
      (void*)&&ZEND_NULL_LABEL,
55956
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
55957
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55958
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55959
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55960
      (void*)&&ZEND_NULL_LABEL,
55961
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55962
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55963
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55964
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55965
      (void*)&&ZEND_NULL_LABEL,
55966
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55967
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_LABEL,
55968
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_LABEL,
55969
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_LABEL,
55970
      (void*)&&ZEND_NULL_LABEL,
55971
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_LABEL,
55972
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
55973
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
55974
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
55975
      (void*)&&ZEND_NULL_LABEL,
55976
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_LABEL,
55977
      (void*)&&ZEND_NULL_LABEL,
55978
      (void*)&&ZEND_NULL_LABEL,
55979
      (void*)&&ZEND_NULL_LABEL,
55980
      (void*)&&ZEND_NULL_LABEL,
55981
      (void*)&&ZEND_NULL_LABEL,
55982
      (void*)&&ZEND_NULL_LABEL,
55983
      (void*)&&ZEND_NULL_LABEL,
55984
      (void*)&&ZEND_NULL_LABEL,
55985
      (void*)&&ZEND_NULL_LABEL,
55986
      (void*)&&ZEND_NULL_LABEL,
55987
      (void*)&&ZEND_NULL_LABEL,
55988
      (void*)&&ZEND_NULL_LABEL,
55989
      (void*)&&ZEND_NULL_LABEL,
55990
      (void*)&&ZEND_NULL_LABEL,
55991
      (void*)&&ZEND_NULL_LABEL,
55992
      (void*)&&ZEND_NULL_LABEL,
55993
      (void*)&&ZEND_NULL_LABEL,
55994
      (void*)&&ZEND_NULL_LABEL,
55995
      (void*)&&ZEND_NULL_LABEL,
55996
      (void*)&&ZEND_NULL_LABEL,
55997
      (void*)&&ZEND_NULL_LABEL,
55998
      (void*)&&ZEND_NULL_LABEL,
55999
      (void*)&&ZEND_NULL_LABEL,
56000
      (void*)&&ZEND_NULL_LABEL,
56001
      (void*)&&ZEND_NULL_LABEL,
56002
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
56003
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
56004
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56005
      (void*)&&ZEND_NULL_LABEL,
56006
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56007
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56008
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56009
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56010
      (void*)&&ZEND_NULL_LABEL,
56011
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56012
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56013
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56014
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56015
      (void*)&&ZEND_NULL_LABEL,
56016
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56017
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_LABEL,
56018
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_LABEL,
56019
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_LABEL,
56020
      (void*)&&ZEND_NULL_LABEL,
56021
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_LABEL,
56022
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_LABEL,
56023
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_LABEL,
56024
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56025
      (void*)&&ZEND_NULL_LABEL,
56026
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_LABEL,
56027
      (void*)&&ZEND_NULL_LABEL,
56028
      (void*)&&ZEND_NULL_LABEL,
56029
      (void*)&&ZEND_NULL_LABEL,
56030
      (void*)&&ZEND_NULL_LABEL,
56031
      (void*)&&ZEND_NULL_LABEL,
56032
      (void*)&&ZEND_NULL_LABEL,
56033
      (void*)&&ZEND_NULL_LABEL,
56034
      (void*)&&ZEND_NULL_LABEL,
56035
      (void*)&&ZEND_NULL_LABEL,
56036
      (void*)&&ZEND_NULL_LABEL,
56037
      (void*)&&ZEND_NULL_LABEL,
56038
      (void*)&&ZEND_NULL_LABEL,
56039
      (void*)&&ZEND_NULL_LABEL,
56040
      (void*)&&ZEND_NULL_LABEL,
56041
      (void*)&&ZEND_NULL_LABEL,
56042
      (void*)&&ZEND_NULL_LABEL,
56043
      (void*)&&ZEND_NULL_LABEL,
56044
      (void*)&&ZEND_NULL_LABEL,
56045
      (void*)&&ZEND_NULL_LABEL,
56046
      (void*)&&ZEND_NULL_LABEL,
56047
      (void*)&&ZEND_NULL_LABEL,
56048
      (void*)&&ZEND_NULL_LABEL,
56049
      (void*)&&ZEND_NULL_LABEL,
56050
      (void*)&&ZEND_NULL_LABEL,
56051
      (void*)&&ZEND_NULL_LABEL,
56052
      (void*)&&ZEND_NULL_LABEL,
56053
      (void*)&&ZEND_NULL_LABEL,
56054
      (void*)&&ZEND_NULL_LABEL,
56055
      (void*)&&ZEND_NULL_LABEL,
56056
      (void*)&&ZEND_NULL_LABEL,
56057
      (void*)&&ZEND_NULL_LABEL,
56058
      (void*)&&ZEND_NULL_LABEL,
56059
      (void*)&&ZEND_NULL_LABEL,
56060
      (void*)&&ZEND_NULL_LABEL,
56061
      (void*)&&ZEND_NULL_LABEL,
56062
      (void*)&&ZEND_NULL_LABEL,
56063
      (void*)&&ZEND_NULL_LABEL,
56064
      (void*)&&ZEND_NULL_LABEL,
56065
      (void*)&&ZEND_NULL_LABEL,
56066
      (void*)&&ZEND_NULL_LABEL,
56067
      (void*)&&ZEND_NULL_LABEL,
56068
      (void*)&&ZEND_NULL_LABEL,
56069
      (void*)&&ZEND_NULL_LABEL,
56070
      (void*)&&ZEND_NULL_LABEL,
56071
      (void*)&&ZEND_NULL_LABEL,
56072
      (void*)&&ZEND_NULL_LABEL,
56073
      (void*)&&ZEND_NULL_LABEL,
56074
      (void*)&&ZEND_NULL_LABEL,
56075
      (void*)&&ZEND_NULL_LABEL,
56076
      (void*)&&ZEND_NULL_LABEL,
56077
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
56078
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
56079
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
56080
      (void*)&&ZEND_NULL_LABEL,
56081
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
56082
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
56083
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
56084
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56085
      (void*)&&ZEND_NULL_LABEL,
56086
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56087
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
56088
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
56089
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56090
      (void*)&&ZEND_NULL_LABEL,
56091
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56092
      (void*)&&ZEND_NULL_LABEL,
56093
      (void*)&&ZEND_NULL_LABEL,
56094
      (void*)&&ZEND_NULL_LABEL,
56095
      (void*)&&ZEND_NULL_LABEL,
56096
      (void*)&&ZEND_NULL_LABEL,
56097
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
56098
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
56099
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
56100
      (void*)&&ZEND_NULL_LABEL,
56101
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_LABEL,
56102
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_LABEL,
56103
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_LABEL,
56104
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
56105
      (void*)&&ZEND_NULL_LABEL,
56106
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
56107
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
56108
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
56109
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56110
      (void*)&&ZEND_NULL_LABEL,
56111
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56112
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
56113
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
56114
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56115
      (void*)&&ZEND_NULL_LABEL,
56116
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56117
      (void*)&&ZEND_NULL_LABEL,
56118
      (void*)&&ZEND_NULL_LABEL,
56119
      (void*)&&ZEND_NULL_LABEL,
56120
      (void*)&&ZEND_NULL_LABEL,
56121
      (void*)&&ZEND_NULL_LABEL,
56122
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_LABEL,
56123
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_LABEL,
56124
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
56125
      (void*)&&ZEND_NULL_LABEL,
56126
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
56127
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
56128
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
56129
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56130
      (void*)&&ZEND_NULL_LABEL,
56131
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56132
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56133
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56134
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56135
      (void*)&&ZEND_NULL_LABEL,
56136
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56137
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56138
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56139
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56140
      (void*)&&ZEND_NULL_LABEL,
56141
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56142
      (void*)&&ZEND_NULL_LABEL,
56143
      (void*)&&ZEND_NULL_LABEL,
56144
      (void*)&&ZEND_NULL_LABEL,
56145
      (void*)&&ZEND_NULL_LABEL,
56146
      (void*)&&ZEND_NULL_LABEL,
56147
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_LABEL,
56148
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_LABEL,
56149
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56150
      (void*)&&ZEND_NULL_LABEL,
56151
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_LABEL,
56152
      (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_LABEL,
56153
      (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_LABEL,
56154
      (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_LABEL,
56155
      (void*)&&ZEND_NULL_LABEL,
56156
      (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_LABEL,
56157
      (void*)&&ZEND_NULL_LABEL,
56158
      (void*)&&ZEND_NULL_LABEL,
56159
      (void*)&&ZEND_NULL_LABEL,
56160
      (void*)&&ZEND_NULL_LABEL,
56161
      (void*)&&ZEND_NULL_LABEL,
56162
      (void*)&&ZEND_NULL_LABEL,
56163
      (void*)&&ZEND_NULL_LABEL,
56164
      (void*)&&ZEND_NULL_LABEL,
56165
      (void*)&&ZEND_NULL_LABEL,
56166
      (void*)&&ZEND_NULL_LABEL,
56167
      (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CONST_LABEL,
56168
      (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
56169
      (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
56170
      (void*)&&ZEND_NULL_LABEL,
56171
      (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CV_LABEL,
56172
      (void*)&&ZEND_NULL_LABEL,
56173
      (void*)&&ZEND_NULL_LABEL,
56174
      (void*)&&ZEND_NULL_LABEL,
56175
      (void*)&&ZEND_NULL_LABEL,
56176
      (void*)&&ZEND_NULL_LABEL,
56177
      (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CONST_LABEL,
56178
      (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
56179
      (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
56180
      (void*)&&ZEND_NULL_LABEL,
56181
      (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CV_LABEL,
56182
      (void*)&&ZEND_NULL_LABEL,
56183
      (void*)&&ZEND_NULL_LABEL,
56184
      (void*)&&ZEND_NULL_LABEL,
56185
      (void*)&&ZEND_NULL_LABEL,
56186
      (void*)&&ZEND_NULL_LABEL,
56187
      (void*)&&ZEND_NULL_LABEL,
56188
      (void*)&&ZEND_NULL_LABEL,
56189
      (void*)&&ZEND_NULL_LABEL,
56190
      (void*)&&ZEND_NULL_LABEL,
56191
      (void*)&&ZEND_NULL_LABEL,
56192
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_LABEL,
56193
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
56194
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
56195
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_LABEL,
56196
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_LABEL,
56197
      (void*)&&ZEND_NULL_LABEL,
56198
      (void*)&&ZEND_NULL_LABEL,
56199
      (void*)&&ZEND_NULL_LABEL,
56200
      (void*)&&ZEND_NULL_LABEL,
56201
      (void*)&&ZEND_NULL_LABEL,
56202
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_LABEL,
56203
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
56204
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
56205
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_LABEL,
56206
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_LABEL,
56207
      (void*)&&ZEND_NULL_LABEL,
56208
      (void*)&&ZEND_NULL_LABEL,
56209
      (void*)&&ZEND_NULL_LABEL,
56210
      (void*)&&ZEND_NULL_LABEL,
56211
      (void*)&&ZEND_NULL_LABEL,
56212
      (void*)&&ZEND_NULL_LABEL,
56213
      (void*)&&ZEND_NULL_LABEL,
56214
      (void*)&&ZEND_NULL_LABEL,
56215
      (void*)&&ZEND_NULL_LABEL,
56216
      (void*)&&ZEND_NULL_LABEL,
56217
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_LABEL,
56218
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
56219
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
56220
      (void*)&&ZEND_NULL_LABEL,
56221
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_LABEL,
56222
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_LABEL,
56223
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
56224
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
56225
      (void*)&&ZEND_NULL_LABEL,
56226
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_LABEL,
56227
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_LABEL,
56228
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
56229
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
56230
      (void*)&&ZEND_NULL_LABEL,
56231
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_LABEL,
56232
      (void*)&&ZEND_ASSIGN_STATIC_PROP_OP_SPEC_LABEL,
56233
      (void*)&&ZEND_NULL_LABEL,
56234
      (void*)&&ZEND_NULL_LABEL,
56235
      (void*)&&ZEND_NULL_LABEL,
56236
      (void*)&&ZEND_NULL_LABEL,
56237
      (void*)&&ZEND_NULL_LABEL,
56238
      (void*)&&ZEND_NULL_LABEL,
56239
      (void*)&&ZEND_NULL_LABEL,
56240
      (void*)&&ZEND_NULL_LABEL,
56241
      (void*)&&ZEND_NULL_LABEL,
56242
      (void*)&&ZEND_NULL_LABEL,
56243
      (void*)&&ZEND_NULL_LABEL,
56244
      (void*)&&ZEND_NULL_LABEL,
56245
      (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_VAR_LABEL,
56246
      (void*)&&ZEND_NULL_LABEL,
56247
      (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_CV_LABEL,
56248
      (void*)&&ZEND_NULL_LABEL,
56249
      (void*)&&ZEND_NULL_LABEL,
56250
      (void*)&&ZEND_NULL_LABEL,
56251
      (void*)&&ZEND_NULL_LABEL,
56252
      (void*)&&ZEND_NULL_LABEL,
56253
      (void*)&&ZEND_NULL_LABEL,
56254
      (void*)&&ZEND_NULL_LABEL,
56255
      (void*)&&ZEND_ASSIGN_REF_SPEC_CV_VAR_LABEL,
56256
      (void*)&&ZEND_NULL_LABEL,
56257
      (void*)&&ZEND_ASSIGN_REF_SPEC_CV_CV_LABEL,
56258
      (void*)&&ZEND_QM_ASSIGN_SPEC_CONST_LABEL,
56259
      (void*)&&ZEND_QM_ASSIGN_SPEC_TMP_LABEL,
56260
      (void*)&&ZEND_QM_ASSIGN_SPEC_VAR_LABEL,
56261
      (void*)&&ZEND_NULL_LABEL,
56262
      (void*)&&ZEND_QM_ASSIGN_SPEC_CV_LABEL,
56263
      (void*)&&ZEND_NULL_LABEL,
56264
      (void*)&&ZEND_NULL_LABEL,
56265
      (void*)&&ZEND_NULL_LABEL,
56266
      (void*)&&ZEND_NULL_LABEL,
56267
      (void*)&&ZEND_NULL_LABEL,
56268
      (void*)&&ZEND_NULL_LABEL,
56269
      (void*)&&ZEND_NULL_LABEL,
56270
      (void*)&&ZEND_NULL_LABEL,
56271
      (void*)&&ZEND_NULL_LABEL,
56272
      (void*)&&ZEND_NULL_LABEL,
56273
      (void*)&&ZEND_NULL_LABEL,
56274
      (void*)&&ZEND_NULL_LABEL,
56275
      (void*)&&ZEND_NULL_LABEL,
56276
      (void*)&&ZEND_NULL_LABEL,
56277
      (void*)&&ZEND_NULL_LABEL,
56278
      (void*)&&ZEND_NULL_LABEL,
56279
      (void*)&&ZEND_NULL_LABEL,
56280
      (void*)&&ZEND_NULL_LABEL,
56281
      (void*)&&ZEND_NULL_LABEL,
56282
      (void*)&&ZEND_NULL_LABEL,
56283
      (void*)&&ZEND_NULL_LABEL,
56284
      (void*)&&ZEND_NULL_LABEL,
56285
      (void*)&&ZEND_NULL_LABEL,
56286
      (void*)&&ZEND_NULL_LABEL,
56287
      (void*)&&ZEND_NULL_LABEL,
56288
      (void*)&&ZEND_NULL_LABEL,
56289
      (void*)&&ZEND_NULL_LABEL,
56290
      (void*)&&ZEND_NULL_LABEL,
56291
      (void*)&&ZEND_NULL_LABEL,
56292
      (void*)&&ZEND_NULL_LABEL,
56293
      (void*)&&ZEND_NULL_LABEL,
56294
      (void*)&&ZEND_NULL_LABEL,
56295
      (void*)&&ZEND_NULL_LABEL,
56296
      (void*)&&ZEND_NULL_LABEL,
56297
      (void*)&&ZEND_NULL_LABEL,
56298
      (void*)&&ZEND_NULL_LABEL,
56299
      (void*)&&ZEND_NULL_LABEL,
56300
      (void*)&&ZEND_NULL_LABEL,
56301
      (void*)&&ZEND_NULL_LABEL,
56302
      (void*)&&ZEND_NULL_LABEL,
56303
      (void*)&&ZEND_NULL_LABEL,
56304
      (void*)&&ZEND_NULL_LABEL,
56305
      (void*)&&ZEND_NULL_LABEL,
56306
      (void*)&&ZEND_NULL_LABEL,
56307
      (void*)&&ZEND_NULL_LABEL,
56308
      (void*)&&ZEND_NULL_LABEL,
56309
      (void*)&&ZEND_NULL_LABEL,
56310
      (void*)&&ZEND_NULL_LABEL,
56311
      (void*)&&ZEND_NULL_LABEL,
56312
      (void*)&&ZEND_NULL_LABEL,
56313
      (void*)&&ZEND_NULL_LABEL,
56314
      (void*)&&ZEND_NULL_LABEL,
56315
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
56316
      (void*)&&ZEND_NULL_LABEL,
56317
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
56318
      (void*)&&ZEND_NULL_LABEL,
56319
      (void*)&&ZEND_NULL_LABEL,
56320
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56321
      (void*)&&ZEND_NULL_LABEL,
56322
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56323
      (void*)&&ZEND_NULL_LABEL,
56324
      (void*)&&ZEND_NULL_LABEL,
56325
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56326
      (void*)&&ZEND_NULL_LABEL,
56327
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56328
      (void*)&&ZEND_NULL_LABEL,
56329
      (void*)&&ZEND_NULL_LABEL,
56330
      (void*)&&ZEND_NULL_LABEL,
56331
      (void*)&&ZEND_NULL_LABEL,
56332
      (void*)&&ZEND_NULL_LABEL,
56333
      (void*)&&ZEND_NULL_LABEL,
56334
      (void*)&&ZEND_NULL_LABEL,
56335
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
56336
      (void*)&&ZEND_NULL_LABEL,
56337
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_LABEL,
56338
      (void*)&&ZEND_NULL_LABEL,
56339
      (void*)&&ZEND_NULL_LABEL,
56340
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
56341
      (void*)&&ZEND_NULL_LABEL,
56342
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
56343
      (void*)&&ZEND_NULL_LABEL,
56344
      (void*)&&ZEND_NULL_LABEL,
56345
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56346
      (void*)&&ZEND_NULL_LABEL,
56347
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56348
      (void*)&&ZEND_NULL_LABEL,
56349
      (void*)&&ZEND_NULL_LABEL,
56350
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56351
      (void*)&&ZEND_NULL_LABEL,
56352
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56353
      (void*)&&ZEND_NULL_LABEL,
56354
      (void*)&&ZEND_NULL_LABEL,
56355
      (void*)&&ZEND_NULL_LABEL,
56356
      (void*)&&ZEND_NULL_LABEL,
56357
      (void*)&&ZEND_NULL_LABEL,
56358
      (void*)&&ZEND_NULL_LABEL,
56359
      (void*)&&ZEND_NULL_LABEL,
56360
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
56361
      (void*)&&ZEND_NULL_LABEL,
56362
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
56363
      (void*)&&ZEND_NULL_LABEL,
56364
      (void*)&&ZEND_NULL_LABEL,
56365
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56366
      (void*)&&ZEND_NULL_LABEL,
56367
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56368
      (void*)&&ZEND_NULL_LABEL,
56369
      (void*)&&ZEND_NULL_LABEL,
56370
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56371
      (void*)&&ZEND_NULL_LABEL,
56372
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56373
      (void*)&&ZEND_NULL_LABEL,
56374
      (void*)&&ZEND_NULL_LABEL,
56375
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56376
      (void*)&&ZEND_NULL_LABEL,
56377
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56378
      (void*)&&ZEND_NULL_LABEL,
56379
      (void*)&&ZEND_NULL_LABEL,
56380
      (void*)&&ZEND_NULL_LABEL,
56381
      (void*)&&ZEND_NULL_LABEL,
56382
      (void*)&&ZEND_NULL_LABEL,
56383
      (void*)&&ZEND_NULL_LABEL,
56384
      (void*)&&ZEND_NULL_LABEL,
56385
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56386
      (void*)&&ZEND_NULL_LABEL,
56387
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_LABEL,
56388
      (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_LABEL,
56389
      (void*)&&ZEND_NULL_LABEL,
56390
      (void*)&&ZEND_NULL_LABEL,
56391
      (void*)&&ZEND_NULL_LABEL,
56392
      (void*)&&ZEND_NULL_LABEL,
56393
      (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_LABEL,
56394
      (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_LABEL,
56395
      (void*)&&ZEND_NULL_LABEL,
56396
      (void*)&&ZEND_NULL_LABEL,
56397
      (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_LABEL,
56398
      (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_USED_LABEL,
56399
      (void*)&&ZEND_NULL_LABEL,
56400
      (void*)&&ZEND_NULL_LABEL,
56401
      (void*)&&ZEND_NULL_LABEL,
56402
      (void*)&&ZEND_NULL_LABEL,
56403
      (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_LABEL,
56404
      (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_LABEL,
56405
      (void*)&&ZEND_NULL_LABEL,
56406
      (void*)&&ZEND_NULL_LABEL,
56407
      (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_LABEL,
56408
      (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_LABEL,
56409
      (void*)&&ZEND_NULL_LABEL,
56410
      (void*)&&ZEND_NULL_LABEL,
56411
      (void*)&&ZEND_POST_INC_SPEC_VAR_LABEL,
56412
      (void*)&&ZEND_NULL_LABEL,
56413
      (void*)&&ZEND_POST_INC_SPEC_CV_LABEL,
56414
      (void*)&&ZEND_NULL_LABEL,
56415
      (void*)&&ZEND_NULL_LABEL,
56416
      (void*)&&ZEND_POST_DEC_SPEC_VAR_LABEL,
56417
      (void*)&&ZEND_NULL_LABEL,
56418
      (void*)&&ZEND_POST_DEC_SPEC_CV_LABEL,
56419
      (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_LABEL,
56420
      (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_LABEL,
56421
      (void*)&&ZEND_JMP_SPEC_LABEL,
56422
      (void*)&&ZEND_JMPZ_SPEC_CONST_LABEL,
56423
      (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
56424
      (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
56425
      (void*)&&ZEND_NULL_LABEL,
56426
      (void*)&&ZEND_JMPZ_SPEC_CV_LABEL,
56427
      (void*)&&ZEND_JMPNZ_SPEC_CONST_LABEL,
56428
      (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
56429
      (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
56430
      (void*)&&ZEND_NULL_LABEL,
56431
      (void*)&&ZEND_JMPNZ_SPEC_CV_LABEL,
56432
      (void*)&&ZEND_JMPZ_EX_SPEC_CONST_LABEL,
56433
      (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
56434
      (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
56435
      (void*)&&ZEND_NULL_LABEL,
56436
      (void*)&&ZEND_JMPZ_EX_SPEC_CV_LABEL,
56437
      (void*)&&ZEND_JMPNZ_EX_SPEC_CONST_LABEL,
56438
      (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
56439
      (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
56440
      (void*)&&ZEND_NULL_LABEL,
56441
      (void*)&&ZEND_JMPNZ_EX_SPEC_CV_LABEL,
56442
      (void*)&&ZEND_CASE_SPEC_TMPVAR_CONST_LABEL,
56443
      (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
56444
      (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
56445
      (void*)&&ZEND_NULL_LABEL,
56446
      (void*)&&ZEND_CASE_SPEC_TMPVAR_CV_LABEL,
56447
      (void*)&&ZEND_CHECK_VAR_SPEC_CV_UNUSED_LABEL,
56448
      (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
56449
      (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
56450
      (void*)&&ZEND_NULL_LABEL,
56451
      (void*)&&ZEND_NULL_LABEL,
56452
      (void*)&&ZEND_NULL_LABEL,
56453
      (void*)&&ZEND_NULL_LABEL,
56454
      (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_LABEL,
56455
      (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
56456
      (void*)&&ZEND_NULL_LABEL,
56457
      (void*)&&ZEND_NULL_LABEL,
56458
      (void*)&&ZEND_CAST_SPEC_CONST_LABEL,
56459
      (void*)&&ZEND_CAST_SPEC_TMP_LABEL,
56460
      (void*)&&ZEND_CAST_SPEC_VAR_LABEL,
56461
      (void*)&&ZEND_NULL_LABEL,
56462
      (void*)&&ZEND_CAST_SPEC_CV_LABEL,
56463
      (void*)&&ZEND_BOOL_SPEC_CONST_LABEL,
56464
      (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
56465
      (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
56466
      (void*)&&ZEND_NULL_LABEL,
56467
      (void*)&&ZEND_BOOL_SPEC_CV_LABEL,
56468
      (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CONST_LABEL,
56469
      (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
56470
      (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
56471
      (void*)&&ZEND_NULL_LABEL,
56472
      (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CV_LABEL,
56473
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
56474
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56475
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56476
      (void*)&&ZEND_NULL_LABEL,
56477
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
56478
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
56479
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56480
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56481
      (void*)&&ZEND_NULL_LABEL,
56482
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
56483
      (void*)&&ZEND_NULL_LABEL,
56484
      (void*)&&ZEND_NULL_LABEL,
56485
      (void*)&&ZEND_NULL_LABEL,
56486
      (void*)&&ZEND_NULL_LABEL,
56487
      (void*)&&ZEND_NULL_LABEL,
56488
      (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CONST_LABEL,
56489
      (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
56490
      (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
56491
      (void*)&&ZEND_NULL_LABEL,
56492
      (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CV_LABEL,
56493
      (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CONST_LABEL,
56494
      (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
56495
      (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
56496
      (void*)&&ZEND_NULL_LABEL,
56497
      (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CV_LABEL,
56498
      (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CONST_LABEL,
56499
      (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
56500
      (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
56501
      (void*)&&ZEND_NULL_LABEL,
56502
      (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CV_LABEL,
56503
      (void*)&&ZEND_ROPE_END_SPEC_TMP_CONST_LABEL,
56504
      (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
56505
      (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
56506
      (void*)&&ZEND_NULL_LABEL,
56507
      (void*)&&ZEND_ROPE_END_SPEC_TMP_CV_LABEL,
56508
      (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL,
56509
      (void*)&&ZEND_END_SILENCE_SPEC_TMP_LABEL,
56510
      (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL,
56511
      (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL,
56512
      (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL,
56513
      (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
56514
      (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
56515
      (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL,
56516
      (void*)&&ZEND_RETURN_SPEC_CONST_LABEL,
56517
      (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56518
      (void*)&&ZEND_RETURN_SPEC_TMP_LABEL,
56519
      (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56520
      (void*)&&ZEND_RETURN_SPEC_VAR_LABEL,
56521
      (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56522
      (void*)&&ZEND_NULL_LABEL,
56523
      (void*)&&ZEND_NULL_LABEL,
56524
      (void*)&&ZEND_RETURN_SPEC_CV_LABEL,
56525
      (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56526
      (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL,
56527
      (void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL,
56528
      (void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL,
56529
      (void*)&&ZEND_NULL_LABEL,
56530
      (void*)&&ZEND_NULL_LABEL,
56531
      (void*)&&ZEND_SEND_VAL_SPEC_CONST_UNUSED_LABEL,
56532
      (void*)&&ZEND_NULL_LABEL,
56533
      (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
56534
      (void*)&&ZEND_NULL_LABEL,
56535
      (void*)&&ZEND_NULL_LABEL,
56536
      (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
56537
      (void*)&&ZEND_NULL_LABEL,
56538
      (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
56539
      (void*)&&ZEND_NULL_LABEL,
56540
      (void*)&&ZEND_NULL_LABEL,
56541
      (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
56542
      (void*)&&ZEND_NULL_LABEL,
56543
      (void*)&&ZEND_NULL_LABEL,
56544
      (void*)&&ZEND_NULL_LABEL,
56545
      (void*)&&ZEND_NULL_LABEL,
56546
      (void*)&&ZEND_NULL_LABEL,
56547
      (void*)&&ZEND_NULL_LABEL,
56548
      (void*)&&ZEND_NULL_LABEL,
56549
      (void*)&&ZEND_NULL_LABEL,
56550
      (void*)&&ZEND_NULL_LABEL,
56551
      (void*)&&ZEND_NULL_LABEL,
56552
      (void*)&&ZEND_NULL_LABEL,
56553
      (void*)&&ZEND_NULL_LABEL,
56554
      (void*)&&ZEND_NULL_LABEL,
56555
      (void*)&&ZEND_NULL_LABEL,
56556
      (void*)&&ZEND_NULL_LABEL,
56557
      (void*)&&ZEND_NULL_LABEL,
56558
      (void*)&&ZEND_NULL_LABEL,
56559
      (void*)&&ZEND_NULL_LABEL,
56560
      (void*)&&ZEND_NULL_LABEL,
56561
      (void*)&&ZEND_NULL_LABEL,
56562
      (void*)&&ZEND_NULL_LABEL,
56563
      (void*)&&ZEND_NULL_LABEL,
56564
      (void*)&&ZEND_NULL_LABEL,
56565
      (void*)&&ZEND_NULL_LABEL,
56566
      (void*)&&ZEND_NULL_LABEL,
56567
      (void*)&&ZEND_NULL_LABEL,
56568
      (void*)&&ZEND_NULL_LABEL,
56569
      (void*)&&ZEND_NULL_LABEL,
56570
      (void*)&&ZEND_NULL_LABEL,
56571
      (void*)&&ZEND_NULL_LABEL,
56572
      (void*)&&ZEND_NULL_LABEL,
56573
      (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
56574
      (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
56575
      (void*)&&ZEND_NULL_LABEL,
56576
      (void*)&&ZEND_NULL_LABEL,
56577
      (void*)&&ZEND_NULL_LABEL,
56578
      (void*)&&ZEND_NULL_LABEL,
56579
      (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_LABEL,
56580
      (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
56581
      (void*)&&ZEND_NULL_LABEL,
56582
      (void*)&&ZEND_NULL_LABEL,
56583
      (void*)&&ZEND_NULL_LABEL,
56584
      (void*)&&ZEND_NULL_LABEL,
56585
      (void*)&&ZEND_NULL_LABEL,
56586
      (void*)&&ZEND_NULL_LABEL,
56587
      (void*)&&ZEND_NULL_LABEL,
56588
      (void*)&&ZEND_NULL_LABEL,
56589
      (void*)&&ZEND_NULL_LABEL,
56590
      (void*)&&ZEND_NULL_LABEL,
56591
      (void*)&&ZEND_NULL_LABEL,
56592
      (void*)&&ZEND_NULL_LABEL,
56593
      (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
56594
      (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
56595
      (void*)&&ZEND_NULL_LABEL,
56596
      (void*)&&ZEND_NULL_LABEL,
56597
      (void*)&&ZEND_NULL_LABEL,
56598
      (void*)&&ZEND_NULL_LABEL,
56599
      (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_LABEL,
56600
      (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_LABEL,
56601
      (void*)&&ZEND_NULL_LABEL,
56602
      (void*)&&ZEND_NULL_LABEL,
56603
      (void*)&&ZEND_NULL_LABEL,
56604
      (void*)&&ZEND_NULL_LABEL,
56605
      (void*)&&ZEND_NULL_LABEL,
56606
      (void*)&&ZEND_NULL_LABEL,
56607
      (void*)&&ZEND_NULL_LABEL,
56608
      (void*)&&ZEND_NULL_LABEL,
56609
      (void*)&&ZEND_NULL_LABEL,
56610
      (void*)&&ZEND_NULL_LABEL,
56611
      (void*)&&ZEND_NULL_LABEL,
56612
      (void*)&&ZEND_NULL_LABEL,
56613
      (void*)&&ZEND_SEND_REF_SPEC_VAR_CONST_LABEL,
56614
      (void*)&&ZEND_NULL_LABEL,
56615
      (void*)&&ZEND_NULL_LABEL,
56616
      (void*)&&ZEND_SEND_REF_SPEC_VAR_UNUSED_LABEL,
56617
      (void*)&&ZEND_NULL_LABEL,
56618
      (void*)&&ZEND_NULL_LABEL,
56619
      (void*)&&ZEND_NULL_LABEL,
56620
      (void*)&&ZEND_NULL_LABEL,
56621
      (void*)&&ZEND_NULL_LABEL,
56622
      (void*)&&ZEND_NULL_LABEL,
56623
      (void*)&&ZEND_SEND_REF_SPEC_CV_CONST_LABEL,
56624
      (void*)&&ZEND_NULL_LABEL,
56625
      (void*)&&ZEND_NULL_LABEL,
56626
      (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL,
56627
      (void*)&&ZEND_NULL_LABEL,
56628
      (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL,
56629
      (void*)&&ZEND_NULL_LABEL,
56630
      (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL,
56631
      (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL,
56632
      (void*)&&ZEND_NULL_LABEL,
56633
      (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL,
56634
      (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL,
56635
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL,
56636
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
56637
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
56638
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_LABEL,
56639
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CV_LABEL,
56640
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CONST_LABEL,
56641
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
56642
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
56643
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_LABEL,
56644
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CV_LABEL,
56645
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CONST_LABEL,
56646
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
56647
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
56648
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_LABEL,
56649
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CV_LABEL,
56650
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_LABEL,
56651
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
56652
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
56653
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_LABEL,
56654
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CV_LABEL,
56655
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CONST_LABEL,
56656
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
56657
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
56658
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_UNUSED_LABEL,
56659
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CV_LABEL,
56660
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_LABEL,
56661
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
56662
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
56663
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_LABEL,
56664
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_LABEL,
56665
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_LABEL,
56666
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
56667
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
56668
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_LABEL,
56669
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_LABEL,
56670
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_LABEL,
56671
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
56672
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
56673
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_LABEL,
56674
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_LABEL,
56675
      (void*)&&ZEND_NULL_LABEL,
56676
      (void*)&&ZEND_NULL_LABEL,
56677
      (void*)&&ZEND_NULL_LABEL,
56678
      (void*)&&ZEND_NULL_LABEL,
56679
      (void*)&&ZEND_NULL_LABEL,
56680
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_LABEL,
56681
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
56682
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
56683
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL,
56684
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL,
56685
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL,
56686
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56687
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
56688
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56689
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
56690
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56691
      (void*)&&ZEND_NULL_LABEL,
56692
      (void*)&&ZEND_NULL_LABEL,
56693
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL,
56694
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56695
      (void*)&&ZEND_UNSET_VAR_SPEC_CONST_UNUSED_LABEL,
56696
      (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
56697
      (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
56698
      (void*)&&ZEND_NULL_LABEL,
56699
      (void*)&&ZEND_UNSET_VAR_SPEC_CV_UNUSED_LABEL,
56700
      (void*)&&ZEND_NULL_LABEL,
56701
      (void*)&&ZEND_NULL_LABEL,
56702
      (void*)&&ZEND_NULL_LABEL,
56703
      (void*)&&ZEND_NULL_LABEL,
56704
      (void*)&&ZEND_NULL_LABEL,
56705
      (void*)&&ZEND_NULL_LABEL,
56706
      (void*)&&ZEND_NULL_LABEL,
56707
      (void*)&&ZEND_NULL_LABEL,
56708
      (void*)&&ZEND_NULL_LABEL,
56709
      (void*)&&ZEND_NULL_LABEL,
56710
      (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CONST_LABEL,
56711
      (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
56712
      (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
56713
      (void*)&&ZEND_NULL_LABEL,
56714
      (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CV_LABEL,
56715
      (void*)&&ZEND_NULL_LABEL,
56716
      (void*)&&ZEND_NULL_LABEL,
56717
      (void*)&&ZEND_NULL_LABEL,
56718
      (void*)&&ZEND_NULL_LABEL,
56719
      (void*)&&ZEND_NULL_LABEL,
56720
      (void*)&&ZEND_UNSET_DIM_SPEC_CV_CONST_LABEL,
56721
      (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
56722
      (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
56723
      (void*)&&ZEND_NULL_LABEL,
56724
      (void*)&&ZEND_UNSET_DIM_SPEC_CV_CV_LABEL,
56725
      (void*)&&ZEND_NULL_LABEL,
56726
      (void*)&&ZEND_NULL_LABEL,
56727
      (void*)&&ZEND_NULL_LABEL,
56728
      (void*)&&ZEND_NULL_LABEL,
56729
      (void*)&&ZEND_NULL_LABEL,
56730
      (void*)&&ZEND_NULL_LABEL,
56731
      (void*)&&ZEND_NULL_LABEL,
56732
      (void*)&&ZEND_NULL_LABEL,
56733
      (void*)&&ZEND_NULL_LABEL,
56734
      (void*)&&ZEND_NULL_LABEL,
56735
      (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CONST_LABEL,
56736
      (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
56737
      (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
56738
      (void*)&&ZEND_NULL_LABEL,
56739
      (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CV_LABEL,
56740
      (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_LABEL,
56741
      (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
56742
      (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
56743
      (void*)&&ZEND_NULL_LABEL,
56744
      (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CV_LABEL,
56745
      (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CONST_LABEL,
56746
      (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
56747
      (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
56748
      (void*)&&ZEND_NULL_LABEL,
56749
      (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CV_LABEL,
56750
      (void*)&&ZEND_FE_RESET_R_SPEC_CONST_LABEL,
56751
      (void*)&&ZEND_FE_RESET_R_SPEC_TMP_LABEL,
56752
      (void*)&&ZEND_FE_RESET_R_SPEC_VAR_LABEL,
56753
      (void*)&&ZEND_NULL_LABEL,
56754
      (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL,
56755
      (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL,
56756
      (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL,
56757
      (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
56758
      (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
56759
      (void*)&&ZEND_NULL_LABEL,
56760
      (void*)&&ZEND_FETCH_R_SPEC_CV_UNUSED_LABEL,
56761
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CONST_LABEL,
56762
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
56763
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
56764
      (void*)&&ZEND_NULL_LABEL,
56765
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CV_LABEL,
56766
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
56767
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56768
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56769
      (void*)&&ZEND_NULL_LABEL,
56770
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
56771
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
56772
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56773
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56774
      (void*)&&ZEND_NULL_LABEL,
56775
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
56776
      (void*)&&ZEND_NULL_LABEL,
56777
      (void*)&&ZEND_NULL_LABEL,
56778
      (void*)&&ZEND_NULL_LABEL,
56779
      (void*)&&ZEND_NULL_LABEL,
56780
      (void*)&&ZEND_NULL_LABEL,
56781
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CONST_LABEL,
56782
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
56783
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
56784
      (void*)&&ZEND_NULL_LABEL,
56785
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CV_LABEL,
56786
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_LABEL,
56787
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
56788
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
56789
      (void*)&&ZEND_NULL_LABEL,
56790
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CV_LABEL,
56791
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
56792
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56793
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56794
      (void*)&&ZEND_NULL_LABEL,
56795
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
56796
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
56797
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56798
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56799
      (void*)&&ZEND_NULL_LABEL,
56800
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
56801
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_LABEL,
56802
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
56803
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
56804
      (void*)&&ZEND_NULL_LABEL,
56805
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_LABEL,
56806
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CONST_LABEL,
56807
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
56808
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
56809
      (void*)&&ZEND_NULL_LABEL,
56810
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CV_LABEL,
56811
      (void*)&&ZEND_FETCH_W_SPEC_CONST_UNUSED_LABEL,
56812
      (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
56813
      (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
56814
      (void*)&&ZEND_NULL_LABEL,
56815
      (void*)&&ZEND_FETCH_W_SPEC_CV_UNUSED_LABEL,
56816
      (void*)&&ZEND_NULL_LABEL,
56817
      (void*)&&ZEND_NULL_LABEL,
56818
      (void*)&&ZEND_NULL_LABEL,
56819
      (void*)&&ZEND_NULL_LABEL,
56820
      (void*)&&ZEND_NULL_LABEL,
56821
      (void*)&&ZEND_NULL_LABEL,
56822
      (void*)&&ZEND_NULL_LABEL,
56823
      (void*)&&ZEND_NULL_LABEL,
56824
      (void*)&&ZEND_NULL_LABEL,
56825
      (void*)&&ZEND_NULL_LABEL,
56826
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CONST_LABEL,
56827
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
56828
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
56829
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_LABEL,
56830
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CV_LABEL,
56831
      (void*)&&ZEND_NULL_LABEL,
56832
      (void*)&&ZEND_NULL_LABEL,
56833
      (void*)&&ZEND_NULL_LABEL,
56834
      (void*)&&ZEND_NULL_LABEL,
56835
      (void*)&&ZEND_NULL_LABEL,
56836
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CONST_LABEL,
56837
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
56838
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
56839
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_LABEL,
56840
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CV_LABEL,
56841
      (void*)&&ZEND_NULL_LABEL,
56842
      (void*)&&ZEND_NULL_LABEL,
56843
      (void*)&&ZEND_NULL_LABEL,
56844
      (void*)&&ZEND_NULL_LABEL,
56845
      (void*)&&ZEND_NULL_LABEL,
56846
      (void*)&&ZEND_NULL_LABEL,
56847
      (void*)&&ZEND_NULL_LABEL,
56848
      (void*)&&ZEND_NULL_LABEL,
56849
      (void*)&&ZEND_NULL_LABEL,
56850
      (void*)&&ZEND_NULL_LABEL,
56851
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_LABEL,
56852
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
56853
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
56854
      (void*)&&ZEND_NULL_LABEL,
56855
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CV_LABEL,
56856
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_LABEL,
56857
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
56858
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
56859
      (void*)&&ZEND_NULL_LABEL,
56860
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_LABEL,
56861
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CONST_LABEL,
56862
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
56863
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
56864
      (void*)&&ZEND_NULL_LABEL,
56865
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CV_LABEL,
56866
      (void*)&&ZEND_FETCH_RW_SPEC_CONST_UNUSED_LABEL,
56867
      (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
56868
      (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
56869
      (void*)&&ZEND_NULL_LABEL,
56870
      (void*)&&ZEND_FETCH_RW_SPEC_CV_UNUSED_LABEL,
56871
      (void*)&&ZEND_NULL_LABEL,
56872
      (void*)&&ZEND_NULL_LABEL,
56873
      (void*)&&ZEND_NULL_LABEL,
56874
      (void*)&&ZEND_NULL_LABEL,
56875
      (void*)&&ZEND_NULL_LABEL,
56876
      (void*)&&ZEND_NULL_LABEL,
56877
      (void*)&&ZEND_NULL_LABEL,
56878
      (void*)&&ZEND_NULL_LABEL,
56879
      (void*)&&ZEND_NULL_LABEL,
56880
      (void*)&&ZEND_NULL_LABEL,
56881
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_LABEL,
56882
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
56883
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
56884
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_LABEL,
56885
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CV_LABEL,
56886
      (void*)&&ZEND_NULL_LABEL,
56887
      (void*)&&ZEND_NULL_LABEL,
56888
      (void*)&&ZEND_NULL_LABEL,
56889
      (void*)&&ZEND_NULL_LABEL,
56890
      (void*)&&ZEND_NULL_LABEL,
56891
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CONST_LABEL,
56892
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
56893
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
56894
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_LABEL,
56895
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CV_LABEL,
56896
      (void*)&&ZEND_NULL_LABEL,
56897
      (void*)&&ZEND_NULL_LABEL,
56898
      (void*)&&ZEND_NULL_LABEL,
56899
      (void*)&&ZEND_NULL_LABEL,
56900
      (void*)&&ZEND_NULL_LABEL,
56901
      (void*)&&ZEND_NULL_LABEL,
56902
      (void*)&&ZEND_NULL_LABEL,
56903
      (void*)&&ZEND_NULL_LABEL,
56904
      (void*)&&ZEND_NULL_LABEL,
56905
      (void*)&&ZEND_NULL_LABEL,
56906
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_LABEL,
56907
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
56908
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
56909
      (void*)&&ZEND_NULL_LABEL,
56910
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_LABEL,
56911
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_LABEL,
56912
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
56913
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
56914
      (void*)&&ZEND_NULL_LABEL,
56915
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_LABEL,
56916
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_LABEL,
56917
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
56918
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
56919
      (void*)&&ZEND_NULL_LABEL,
56920
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CV_LABEL,
56921
      (void*)&&ZEND_FETCH_IS_SPEC_CONST_UNUSED_LABEL,
56922
      (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
56923
      (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
56924
      (void*)&&ZEND_NULL_LABEL,
56925
      (void*)&&ZEND_FETCH_IS_SPEC_CV_UNUSED_LABEL,
56926
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_LABEL,
56927
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
56928
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
56929
      (void*)&&ZEND_NULL_LABEL,
56930
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CV_LABEL,
56931
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
56932
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56933
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56934
      (void*)&&ZEND_NULL_LABEL,
56935
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
56936
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
56937
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56938
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56939
      (void*)&&ZEND_NULL_LABEL,
56940
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
56941
      (void*)&&ZEND_NULL_LABEL,
56942
      (void*)&&ZEND_NULL_LABEL,
56943
      (void*)&&ZEND_NULL_LABEL,
56944
      (void*)&&ZEND_NULL_LABEL,
56945
      (void*)&&ZEND_NULL_LABEL,
56946
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CONST_LABEL,
56947
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
56948
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
56949
      (void*)&&ZEND_NULL_LABEL,
56950
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CV_LABEL,
56951
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_LABEL,
56952
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
56953
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
56954
      (void*)&&ZEND_NULL_LABEL,
56955
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_LABEL,
56956
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
56957
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56958
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56959
      (void*)&&ZEND_NULL_LABEL,
56960
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
56961
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
56962
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56963
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56964
      (void*)&&ZEND_NULL_LABEL,
56965
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
56966
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_LABEL,
56967
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
56968
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
56969
      (void*)&&ZEND_NULL_LABEL,
56970
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_LABEL,
56971
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_LABEL,
56972
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
56973
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
56974
      (void*)&&ZEND_NULL_LABEL,
56975
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CV_LABEL,
56976
      (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
56977
      (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
56978
      (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
56979
      (void*)&&ZEND_NULL_LABEL,
56980
      (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
56981
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_LABEL,
56982
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56983
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56984
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
56985
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_LABEL,
56986
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_LABEL,
56987
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56988
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56989
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_LABEL,
56990
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_LABEL,
56991
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_LABEL,
56992
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56993
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56994
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
56995
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_LABEL,
56996
      (void*)&&ZEND_NULL_LABEL,
56997
      (void*)&&ZEND_NULL_LABEL,
56998
      (void*)&&ZEND_NULL_LABEL,
56999
      (void*)&&ZEND_NULL_LABEL,
57000
      (void*)&&ZEND_NULL_LABEL,
57001
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_LABEL,
57002
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
57003
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
57004
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
57005
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_LABEL,
57006
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_LABEL,
57007
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
57008
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
57009
      (void*)&&ZEND_NULL_LABEL,
57010
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_LABEL,
57011
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_LABEL,
57012
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
57013
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
57014
      (void*)&&ZEND_NULL_LABEL,
57015
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_LABEL,
57016
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_LABEL,
57017
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
57018
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
57019
      (void*)&&ZEND_NULL_LABEL,
57020
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_LABEL,
57021
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
57022
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
57023
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
57024
      (void*)&&ZEND_NULL_LABEL,
57025
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_LABEL,
57026
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_LABEL,
57027
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
57028
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
57029
      (void*)&&ZEND_NULL_LABEL,
57030
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_LABEL,
57031
      (void*)&&ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_LABEL,
57032
      (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
57033
      (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
57034
      (void*)&&ZEND_NULL_LABEL,
57035
      (void*)&&ZEND_FETCH_UNSET_SPEC_CV_UNUSED_LABEL,
57036
      (void*)&&ZEND_NULL_LABEL,
57037
      (void*)&&ZEND_NULL_LABEL,
57038
      (void*)&&ZEND_NULL_LABEL,
57039
      (void*)&&ZEND_NULL_LABEL,
57040
      (void*)&&ZEND_NULL_LABEL,
57041
      (void*)&&ZEND_NULL_LABEL,
57042
      (void*)&&ZEND_NULL_LABEL,
57043
      (void*)&&ZEND_NULL_LABEL,
57044
      (void*)&&ZEND_NULL_LABEL,
57045
      (void*)&&ZEND_NULL_LABEL,
57046
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_LABEL,
57047
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
57048
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
57049
      (void*)&&ZEND_NULL_LABEL,
57050
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_LABEL,
57051
      (void*)&&ZEND_NULL_LABEL,
57052
      (void*)&&ZEND_NULL_LABEL,
57053
      (void*)&&ZEND_NULL_LABEL,
57054
      (void*)&&ZEND_NULL_LABEL,
57055
      (void*)&&ZEND_NULL_LABEL,
57056
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_LABEL,
57057
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
57058
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
57059
      (void*)&&ZEND_NULL_LABEL,
57060
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_LABEL,
57061
      (void*)&&ZEND_NULL_LABEL,
57062
      (void*)&&ZEND_NULL_LABEL,
57063
      (void*)&&ZEND_NULL_LABEL,
57064
      (void*)&&ZEND_NULL_LABEL,
57065
      (void*)&&ZEND_NULL_LABEL,
57066
      (void*)&&ZEND_NULL_LABEL,
57067
      (void*)&&ZEND_NULL_LABEL,
57068
      (void*)&&ZEND_NULL_LABEL,
57069
      (void*)&&ZEND_NULL_LABEL,
57070
      (void*)&&ZEND_NULL_LABEL,
57071
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_LABEL,
57072
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
57073
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
57074
      (void*)&&ZEND_NULL_LABEL,
57075
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_LABEL,
57076
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_LABEL,
57077
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
57078
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
57079
      (void*)&&ZEND_NULL_LABEL,
57080
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_LABEL,
57081
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_LABEL,
57082
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
57083
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
57084
      (void*)&&ZEND_NULL_LABEL,
57085
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_LABEL,
57086
      (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CONST_LABEL,
57087
      (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
57088
      (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
57089
      (void*)&&ZEND_NULL_LABEL,
57090
      (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CV_LABEL,
57091
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57092
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57093
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57094
      (void*)&&ZEND_NULL_LABEL,
57095
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57096
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57097
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57098
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57099
      (void*)&&ZEND_NULL_LABEL,
57100
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57101
      (void*)&&ZEND_NULL_LABEL,
57102
      (void*)&&ZEND_NULL_LABEL,
57103
      (void*)&&ZEND_NULL_LABEL,
57104
      (void*)&&ZEND_NULL_LABEL,
57105
      (void*)&&ZEND_NULL_LABEL,
57106
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57107
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57108
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57109
      (void*)&&ZEND_NULL_LABEL,
57110
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57111
      (void*)&&ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_LABEL,
57112
      (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
57113
      (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
57114
      (void*)&&ZEND_NULL_LABEL,
57115
      (void*)&&ZEND_NULL_LABEL,
57116
      (void*)&&ZEND_NULL_LABEL,
57117
      (void*)&&ZEND_NULL_LABEL,
57118
      (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_LABEL,
57119
      (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_LABEL,
57120
      (void*)&&ZEND_NULL_LABEL,
57121
      (void*)&&ZEND_NULL_LABEL,
57122
      (void*)&&ZEND_EXT_STMT_SPEC_LABEL,
57123
      (void*)&&ZEND_EXT_FCALL_BEGIN_SPEC_LABEL,
57124
      (void*)&&ZEND_EXT_FCALL_END_SPEC_LABEL,
57125
      (void*)&&ZEND_EXT_NOP_SPEC_LABEL,
57126
      (void*)&&ZEND_TICKS_SPEC_LABEL,
57127
      (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_LABEL,
57128
      (void*)&&ZEND_NULL_LABEL,
57129
      (void*)&&ZEND_NULL_LABEL,
57130
      (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_LABEL,
57131
      (void*)&&ZEND_NULL_LABEL,
57132
      (void*)&&ZEND_CATCH_SPEC_CONST_LABEL,
57133
      (void*)&&ZEND_THROW_SPEC_CONST_LABEL,
57134
      (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
57135
      (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
57136
      (void*)&&ZEND_NULL_LABEL,
57137
      (void*)&&ZEND_THROW_SPEC_CV_LABEL,
57138
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_LABEL,
57139
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
57140
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
57141
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57142
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CV_LABEL,
57143
      (void*)&&ZEND_CLONE_SPEC_CONST_LABEL,
57144
      (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
57145
      (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
57146
      (void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL,
57147
      (void*)&&ZEND_CLONE_SPEC_CV_LABEL,
57148
      (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL,
57149
      (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57150
      (void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_LABEL,
57151
      (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57152
      (void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_LABEL,
57153
      (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57154
      (void*)&&ZEND_NULL_LABEL,
57155
      (void*)&&ZEND_NULL_LABEL,
57156
      (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL,
57157
      (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57158
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL,
57159
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57160
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57161
      (void*)&&ZEND_NULL_LABEL,
57162
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL,
57163
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
57164
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57165
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57166
      (void*)&&ZEND_NULL_LABEL,
57167
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
57168
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
57169
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57170
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57171
      (void*)&&ZEND_NULL_LABEL,
57172
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
57173
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
57174
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57175
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57176
      (void*)&&ZEND_NULL_LABEL,
57177
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
57178
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL,
57179
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
57180
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
57181
      (void*)&&ZEND_NULL_LABEL,
57182
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL,
57183
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL,
57184
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57185
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57186
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL,
57187
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL,
57188
      (void*)&&ZEND_NULL_LABEL,
57189
      (void*)&&ZEND_NULL_LABEL,
57190
      (void*)&&ZEND_NULL_LABEL,
57191
      (void*)&&ZEND_NULL_LABEL,
57192
      (void*)&&ZEND_NULL_LABEL,
57193
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL,
57194
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
57195
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
57196
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL,
57197
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL,
57198
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
57199
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57200
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57201
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL,
57202
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
57203
      (void*)&&ZEND_NULL_LABEL,
57204
      (void*)&&ZEND_NULL_LABEL,
57205
      (void*)&&ZEND_NULL_LABEL,
57206
      (void*)&&ZEND_NULL_LABEL,
57207
      (void*)&&ZEND_NULL_LABEL,
57208
      (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_LABEL,
57209
      (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
57210
      (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
57211
      (void*)&&ZEND_NULL_LABEL,
57212
      (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_LABEL,
57213
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_LABEL,
57214
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
57215
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
57216
      (void*)&&ZEND_NULL_LABEL,
57217
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_LABEL,
57218
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
57219
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57220
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57221
      (void*)&&ZEND_NULL_LABEL,
57222
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
57223
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
57224
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57225
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57226
      (void*)&&ZEND_NULL_LABEL,
57227
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
57228
      (void*)&&ZEND_NULL_LABEL,
57229
      (void*)&&ZEND_NULL_LABEL,
57230
      (void*)&&ZEND_NULL_LABEL,
57231
      (void*)&&ZEND_NULL_LABEL,
57232
      (void*)&&ZEND_NULL_LABEL,
57233
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_LABEL,
57234
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
57235
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
57236
      (void*)&&ZEND_NULL_LABEL,
57237
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_LABEL,
57238
      (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
57239
      (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
57240
      (void*)&&ZEND_NULL_LABEL,
57241
      (void*)&&ZEND_NULL_LABEL,
57242
      (void*)&&ZEND_NULL_LABEL,
57243
      (void*)&&ZEND_NULL_LABEL,
57244
      (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_LABEL,
57245
      (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_LABEL,
57246
      (void*)&&ZEND_NULL_LABEL,
57247
      (void*)&&ZEND_NULL_LABEL,
57248
      (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
57249
      (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
57250
      (void*)&&ZEND_NULL_LABEL,
57251
      (void*)&&ZEND_NULL_LABEL,
57252
      (void*)&&ZEND_NULL_LABEL,
57253
      (void*)&&ZEND_NULL_LABEL,
57254
      (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_LABEL,
57255
      (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_LABEL,
57256
      (void*)&&ZEND_NULL_LABEL,
57257
      (void*)&&ZEND_NULL_LABEL,
57258
      (void*)&&ZEND_NULL_LABEL,
57259
      (void*)&&ZEND_NULL_LABEL,
57260
      (void*)&&ZEND_NULL_LABEL,
57261
      (void*)&&ZEND_NULL_LABEL,
57262
      (void*)&&ZEND_NULL_LABEL,
57263
      (void*)&&ZEND_NULL_LABEL,
57264
      (void*)&&ZEND_NULL_LABEL,
57265
      (void*)&&ZEND_NULL_LABEL,
57266
      (void*)&&ZEND_NULL_LABEL,
57267
      (void*)&&ZEND_NULL_LABEL,
57268
      (void*)&&ZEND_NULL_LABEL,
57269
      (void*)&&ZEND_NULL_LABEL,
57270
      (void*)&&ZEND_NULL_LABEL,
57271
      (void*)&&ZEND_NULL_LABEL,
57272
      (void*)&&ZEND_NULL_LABEL,
57273
      (void*)&&ZEND_NULL_LABEL,
57274
      (void*)&&ZEND_NULL_LABEL,
57275
      (void*)&&ZEND_NULL_LABEL,
57276
      (void*)&&ZEND_NULL_LABEL,
57277
      (void*)&&ZEND_NULL_LABEL,
57278
      (void*)&&ZEND_NULL_LABEL,
57279
      (void*)&&ZEND_NULL_LABEL,
57280
      (void*)&&ZEND_NULL_LABEL,
57281
      (void*)&&ZEND_NULL_LABEL,
57282
      (void*)&&ZEND_NULL_LABEL,
57283
      (void*)&&ZEND_NULL_LABEL,
57284
      (void*)&&ZEND_NULL_LABEL,
57285
      (void*)&&ZEND_NULL_LABEL,
57286
      (void*)&&ZEND_NULL_LABEL,
57287
      (void*)&&ZEND_NULL_LABEL,
57288
      (void*)&&ZEND_NULL_LABEL,
57289
      (void*)&&ZEND_NULL_LABEL,
57290
      (void*)&&ZEND_NULL_LABEL,
57291
      (void*)&&ZEND_NULL_LABEL,
57292
      (void*)&&ZEND_NULL_LABEL,
57293
      (void*)&&ZEND_NULL_LABEL,
57294
      (void*)&&ZEND_NULL_LABEL,
57295
      (void*)&&ZEND_NULL_LABEL,
57296
      (void*)&&ZEND_NULL_LABEL,
57297
      (void*)&&ZEND_NULL_LABEL,
57298
      (void*)&&ZEND_SEND_VAR_SPEC_VAR_CONST_LABEL,
57299
      (void*)&&ZEND_NULL_LABEL,
57300
      (void*)&&ZEND_NULL_LABEL,
57301
      (void*)&&ZEND_SEND_VAR_SPEC_VAR_UNUSED_LABEL,
57302
      (void*)&&ZEND_NULL_LABEL,
57303
      (void*)&&ZEND_NULL_LABEL,
57304
      (void*)&&ZEND_NULL_LABEL,
57305
      (void*)&&ZEND_NULL_LABEL,
57306
      (void*)&&ZEND_NULL_LABEL,
57307
      (void*)&&ZEND_NULL_LABEL,
57308
      (void*)&&ZEND_SEND_VAR_SPEC_CV_CONST_LABEL,
57309
      (void*)&&ZEND_NULL_LABEL,
57310
      (void*)&&ZEND_NULL_LABEL,
57311
      (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL,
57312
      (void*)&&ZEND_NULL_LABEL,
57313
      (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL,
57314
      (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
57315
      (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
57316
      (void*)&&ZEND_NULL_LABEL,
57317
      (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL,
57318
      (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL,
57319
      (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL,
57320
      (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL,
57321
      (void*)&&ZEND_SEND_USER_SPEC_VAR_LABEL,
57322
      (void*)&&ZEND_NULL_LABEL,
57323
      (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL,
57324
      (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL,
57325
      (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
57326
      (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
57327
      (void*)&&ZEND_NULL_LABEL,
57328
      (void*)&&ZEND_STRLEN_SPEC_CV_LABEL,
57329
      (void*)&&ZEND_DEFINED_SPEC_CONST_LABEL,
57330
      (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_LABEL,
57331
      (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
57332
      (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
57333
      (void*)&&ZEND_NULL_LABEL,
57334
      (void*)&&ZEND_TYPE_CHECK_SPEC_CV_LABEL,
57335
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL,
57336
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_LABEL,
57337
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_LABEL,
57338
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_LABEL,
57339
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_LABEL,
57340
      (void*)&&ZEND_FE_RESET_RW_SPEC_CONST_LABEL,
57341
      (void*)&&ZEND_FE_RESET_RW_SPEC_TMP_LABEL,
57342
      (void*)&&ZEND_FE_RESET_RW_SPEC_VAR_LABEL,
57343
      (void*)&&ZEND_NULL_LABEL,
57344
      (void*)&&ZEND_FE_RESET_RW_SPEC_CV_LABEL,
57345
      (void*)&&ZEND_FE_FETCH_RW_SPEC_VAR_LABEL,
57346
      (void*)&&ZEND_FE_FREE_SPEC_TMPVAR_LABEL,
57347
      (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_LABEL,
57348
      (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
57349
      (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
57350
      (void*)&&ZEND_NULL_LABEL,
57351
      (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CV_LABEL,
57352
      (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_LABEL,
57353
      (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL,
57354
      (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
57355
      (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
57356
      (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL,
57357
      (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL,
57358
      (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
57359
      (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
57360
      (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_LABEL,
57361
      (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_LABEL,
57362
      (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
57363
      (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
57364
      (void*)&&ZEND_NULL_LABEL,
57365
      (void*)&&ZEND_NULL_LABEL,
57366
      (void*)&&ZEND_NULL_LABEL,
57367
      (void*)&&ZEND_NULL_LABEL,
57368
      (void*)&&ZEND_NULL_LABEL,
57369
      (void*)&&ZEND_NULL_LABEL,
57370
      (void*)&&ZEND_NULL_LABEL,
57371
      (void*)&&ZEND_NULL_LABEL,
57372
      (void*)&&ZEND_NULL_LABEL,
57373
      (void*)&&ZEND_NULL_LABEL,
57374
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_LABEL,
57375
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57376
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57377
      (void*)&&ZEND_NULL_LABEL,
57378
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CV_LABEL,
57379
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
57380
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57381
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57382
      (void*)&&ZEND_NULL_LABEL,
57383
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_LABEL,
57384
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CONST_LABEL,
57385
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57386
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57387
      (void*)&&ZEND_NULL_LABEL,
57388
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CV_LABEL,
57389
      (void*)&&ZEND_NULL_LABEL,
57390
      (void*)&&ZEND_NULL_LABEL,
57391
      (void*)&&ZEND_NULL_LABEL,
57392
      (void*)&&ZEND_NULL_LABEL,
57393
      (void*)&&ZEND_NULL_LABEL,
57394
      (void*)&&ZEND_NULL_LABEL,
57395
      (void*)&&ZEND_NULL_LABEL,
57396
      (void*)&&ZEND_NULL_LABEL,
57397
      (void*)&&ZEND_NULL_LABEL,
57398
      (void*)&&ZEND_NULL_LABEL,
57399
      (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CONST_LABEL,
57400
      (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57401
      (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57402
      (void*)&&ZEND_NULL_LABEL,
57403
      (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CV_LABEL,
57404
      (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
57405
      (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57406
      (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57407
      (void*)&&ZEND_NULL_LABEL,
57408
      (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_LABEL,
57409
      (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CONST_LABEL,
57410
      (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57411
      (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57412
      (void*)&&ZEND_NULL_LABEL,
57413
      (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CV_LABEL,
57414
      (void*)&&ZEND_ECHO_SPEC_CONST_LABEL,
57415
      (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
57416
      (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
57417
      (void*)&&ZEND_NULL_LABEL,
57418
      (void*)&&ZEND_ECHO_SPEC_CV_LABEL,
57419
      (void*)&&ZEND_NULL_LABEL,
57420
      (void*)&&ZEND_NULL_LABEL,
57421
      (void*)&&ZEND_NULL_LABEL,
57422
      (void*)&&ZEND_NULL_LABEL,
57423
      (void*)&&ZEND_NULL_LABEL,
57424
      (void*)&&ZEND_NULL_LABEL,
57425
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
57426
      (void*)&&ZEND_NULL_LABEL,
57427
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
57428
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
57429
      (void*)&&ZEND_NULL_LABEL,
57430
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
57431
      (void*)&&ZEND_NULL_LABEL,
57432
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
57433
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
57434
      (void*)&&ZEND_NULL_LABEL,
57435
      (void*)&&ZEND_NULL_LABEL,
57436
      (void*)&&ZEND_NULL_LABEL,
57437
      (void*)&&ZEND_NULL_LABEL,
57438
      (void*)&&ZEND_NULL_LABEL,
57439
      (void*)&&ZEND_NULL_LABEL,
57440
      (void*)&&ZEND_INSTANCEOF_SPEC_CV_CONST_LABEL,
57441
      (void*)&&ZEND_NULL_LABEL,
57442
      (void*)&&ZEND_INSTANCEOF_SPEC_CV_VAR_LABEL,
57443
      (void*)&&ZEND_INSTANCEOF_SPEC_CV_UNUSED_LABEL,
57444
      (void*)&&ZEND_NULL_LABEL,
57445
      (void*)&&ZEND_GENERATOR_CREATE_SPEC_LABEL,
57446
      (void*)&&ZEND_NULL_LABEL,
57447
      (void*)&&ZEND_NULL_LABEL,
57448
      (void*)&&ZEND_MAKE_REF_SPEC_VAR_UNUSED_LABEL,
57449
      (void*)&&ZEND_NULL_LABEL,
57450
      (void*)&&ZEND_MAKE_REF_SPEC_CV_UNUSED_LABEL,
57451
      (void*)&&ZEND_DECLARE_FUNCTION_SPEC_LABEL,
57452
      (void*)&&ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_LABEL,
57453
      (void*)&&ZEND_DECLARE_CONST_SPEC_CONST_CONST_LABEL,
57454
      (void*)&&ZEND_DECLARE_CLASS_SPEC_CONST_LABEL,
57455
      (void*)&&ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_LABEL,
57456
      (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL,
57457
      (void*)&&ZEND_ADD_ARRAY_UNPACK_SPEC_LABEL,
57458
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_LABEL,
57459
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
57460
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
57461
      (void*)&&ZEND_NULL_LABEL,
57462
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_LABEL,
57463
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
57464
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57465
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57466
      (void*)&&ZEND_NULL_LABEL,
57467
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
57468
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
57469
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57470
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57471
      (void*)&&ZEND_NULL_LABEL,
57472
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
57473
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_LABEL,
57474
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57475
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57476
      (void*)&&ZEND_NULL_LABEL,
57477
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_LABEL,
57478
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_LABEL,
57479
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
57480
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
57481
      (void*)&&ZEND_NULL_LABEL,
57482
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL,
57483
      (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL,
57484
      (void*)&&ZEND_USER_OPCODE_SPEC_LABEL,
57485
      (void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL,
57486
      (void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL,
57487
      (void*)&&ZEND_JMP_SET_SPEC_TMP_LABEL,
57488
      (void*)&&ZEND_JMP_SET_SPEC_VAR_LABEL,
57489
      (void*)&&ZEND_NULL_LABEL,
57490
      (void*)&&ZEND_JMP_SET_SPEC_CV_LABEL,
57491
      (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
57492
      (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL,
57493
      (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL,
57494
      (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL,
57495
      (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
57496
      (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
57497
      (void*)&&ZEND_NULL_LABEL,
57498
      (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
57499
      (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL,
57500
      (void*)&&ZEND_NULL_LABEL,
57501
      (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
57502
      (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
57503
      (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
57504
      (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL,
57505
      (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
57506
      (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL,
57507
      (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL,
57508
      (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL,
57509
      (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
57510
      (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
57511
      (void*)&&ZEND_YIELD_SPEC_CONST_UNUSED_LABEL,
57512
      (void*)&&ZEND_YIELD_SPEC_CONST_CV_LABEL,
57513
      (void*)&&ZEND_YIELD_SPEC_TMP_CONST_LABEL,
57514
      (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
57515
      (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
57516
      (void*)&&ZEND_YIELD_SPEC_TMP_UNUSED_LABEL,
57517
      (void*)&&ZEND_YIELD_SPEC_TMP_CV_LABEL,
57518
      (void*)&&ZEND_YIELD_SPEC_VAR_CONST_LABEL,
57519
      (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
57520
      (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
57521
      (void*)&&ZEND_YIELD_SPEC_VAR_UNUSED_LABEL,
57522
      (void*)&&ZEND_YIELD_SPEC_VAR_CV_LABEL,
57523
      (void*)&&ZEND_YIELD_SPEC_UNUSED_CONST_LABEL,
57524
      (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
57525
      (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
57526
      (void*)&&ZEND_YIELD_SPEC_UNUSED_UNUSED_LABEL,
57527
      (void*)&&ZEND_YIELD_SPEC_UNUSED_CV_LABEL,
57528
      (void*)&&ZEND_YIELD_SPEC_CV_CONST_LABEL,
57529
      (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
57530
      (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
57531
      (void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL,
57532
      (void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL,
57533
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL,
57534
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57535
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_LABEL,
57536
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57537
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_LABEL,
57538
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57539
      (void*)&&ZEND_NULL_LABEL,
57540
      (void*)&&ZEND_NULL_LABEL,
57541
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL,
57542
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57543
      (void*)&&ZEND_FAST_CALL_SPEC_LABEL,
57544
      (void*)&&ZEND_FAST_RET_SPEC_LABEL,
57545
      (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL,
57546
      (void*)&&ZEND_SEND_UNPACK_SPEC_LABEL,
57547
      (void*)&&ZEND_YIELD_FROM_SPEC_CONST_LABEL,
57548
      (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
57549
      (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
57550
      (void*)&&ZEND_NULL_LABEL,
57551
      (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL,
57552
      (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL,
57553
      (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL,
57554
      (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL,
57555
      (void*)&&ZEND_COALESCE_SPEC_TMP_LABEL,
57556
      (void*)&&ZEND_COALESCE_SPEC_VAR_LABEL,
57557
      (void*)&&ZEND_NULL_LABEL,
57558
      (void*)&&ZEND_COALESCE_SPEC_CV_LABEL,
57559
      (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL,
57560
      (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
57561
      (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
57562
      (void*)&&ZEND_NULL_LABEL,
57563
      (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL,
57564
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
57565
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57566
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57567
      (void*)&&ZEND_NULL_LABEL,
57568
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
57569
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
57570
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57571
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57572
      (void*)&&ZEND_NULL_LABEL,
57573
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
57574
      (void*)&&ZEND_NULL_LABEL,
57575
      (void*)&&ZEND_NULL_LABEL,
57576
      (void*)&&ZEND_NULL_LABEL,
57577
      (void*)&&ZEND_NULL_LABEL,
57578
      (void*)&&ZEND_NULL_LABEL,
57579
      (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL,
57580
      (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
57581
      (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
57582
      (void*)&&ZEND_NULL_LABEL,
57583
      (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL,
57584
      (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57585
      (void*)&&ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_LABEL,
57586
      (void*)&&ZEND_NULL_LABEL,
57587
      (void*)&&ZEND_NULL_LABEL,
57588
      (void*)&&ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57589
      (void*)&&ZEND_NULL_LABEL,
57590
      (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_LABEL,
57591
      (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_LABEL,
57592
      (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_LABEL,
57593
      (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_LABEL,
57594
      (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_LABEL,
57595
      (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_LABEL,
57596
      (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_LABEL,
57597
      (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_LABEL,
57598
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_LABEL,
57599
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57600
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57601
      (void*)&&ZEND_NULL_LABEL,
57602
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57603
      (void*)&&ZEND_NULL_LABEL,
57604
      (void*)&&ZEND_NULL_LABEL,
57605
      (void*)&&ZEND_NULL_LABEL,
57606
      (void*)&&ZEND_NULL_LABEL,
57607
      (void*)&&ZEND_NULL_LABEL,
57608
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_LABEL,
57609
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57610
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57611
      (void*)&&ZEND_NULL_LABEL,
57612
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57613
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_LABEL,
57614
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57615
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57616
      (void*)&&ZEND_NULL_LABEL,
57617
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57618
      (void*)&&ZEND_NULL_LABEL,
57619
      (void*)&&ZEND_NULL_LABEL,
57620
      (void*)&&ZEND_NULL_LABEL,
57621
      (void*)&&ZEND_NULL_LABEL,
57622
      (void*)&&ZEND_NULL_LABEL,
57623
      (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL,
57624
      (void*)&&ZEND_BIND_STATIC_SPEC_CV_LABEL,
57625
      (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL,
57626
      (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_LABEL,
57627
      (void*)&&ZEND_NULL_LABEL,
57628
      (void*)&&ZEND_NULL_LABEL,
57629
      (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
57630
      (void*)&&ZEND_NULL_LABEL,
57631
      (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL,
57632
      (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL,
57633
      (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57634
      (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57635
      (void*)&&ZEND_NULL_LABEL,
57636
      (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57637
      (void*)&&ZEND_SWITCH_STRING_SPEC_CONST_CONST_LABEL,
57638
      (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57639
      (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57640
      (void*)&&ZEND_NULL_LABEL,
57641
      (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57642
      (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL,
57643
      (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL,
57644
      (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL,
57645
      (void*)&&ZEND_NULL_LABEL,
57646
      (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL,
57647
      (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL,
57648
      (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
57649
      (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
57650
      (void*)&&ZEND_NULL_LABEL,
57651
      (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL,
57652
      (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL,
57653
      (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
57654
      (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
57655
      (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57656
      (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL,
57657
      (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57658
      (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL,
57659
      (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL,
57660
      (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL,
57661
      (void*)&&ZEND_NULL_LABEL,
57662
      (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL,
57663
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
57664
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
57665
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
57666
      (void*)&&ZEND_NULL_LABEL,
57667
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
57668
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
57669
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57670
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57671
      (void*)&&ZEND_NULL_LABEL,
57672
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
57673
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
57674
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57675
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57676
      (void*)&&ZEND_NULL_LABEL,
57677
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
57678
      (void*)&&ZEND_NULL_LABEL,
57679
      (void*)&&ZEND_NULL_LABEL,
57680
      (void*)&&ZEND_NULL_LABEL,
57681
      (void*)&&ZEND_NULL_LABEL,
57682
      (void*)&&ZEND_NULL_LABEL,
57683
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
57684
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
57685
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
57686
      (void*)&&ZEND_NULL_LABEL,
57687
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
57688
      (void*)&&ZEND_MATCH_SPEC_CONST_CONST_LABEL,
57689
      (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57690
      (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57691
      (void*)&&ZEND_NULL_LABEL,
57692
      (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57693
      (void*)&&ZEND_NULL_LABEL,
57694
      (void*)&&ZEND_NULL_LABEL,
57695
      (void*)&&ZEND_NULL_LABEL,
57696
      (void*)&&ZEND_NULL_LABEL,
57697
      (void*)&&ZEND_NULL_LABEL,
57698
      (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CONST_LABEL,
57699
      (void*)&&ZEND_CASE_STRICT_SPEC_TMP_TMP_LABEL,
57700
      (void*)&&ZEND_CASE_STRICT_SPEC_TMP_VAR_LABEL,
57701
      (void*)&&ZEND_NULL_LABEL,
57702
      (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CV_LABEL,
57703
      (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CONST_LABEL,
57704
      (void*)&&ZEND_CASE_STRICT_SPEC_VAR_TMP_LABEL,
57705
      (void*)&&ZEND_CASE_STRICT_SPEC_VAR_VAR_LABEL,
57706
      (void*)&&ZEND_NULL_LABEL,
57707
      (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CV_LABEL,
57708
      (void*)&&ZEND_NULL_LABEL,
57709
      (void*)&&ZEND_NULL_LABEL,
57710
      (void*)&&ZEND_NULL_LABEL,
57711
      (void*)&&ZEND_NULL_LABEL,
57712
      (void*)&&ZEND_NULL_LABEL,
57713
      (void*)&&ZEND_NULL_LABEL,
57714
      (void*)&&ZEND_NULL_LABEL,
57715
      (void*)&&ZEND_NULL_LABEL,
57716
      (void*)&&ZEND_NULL_LABEL,
57717
      (void*)&&ZEND_NULL_LABEL,
57718
      (void*)&&ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_LABEL,
57719
      (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57720
      (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57721
      (void*)&&ZEND_NULL_LABEL,
57722
      (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57723
      (void*)&&ZEND_JMP_NULL_SPEC_CONST_LABEL,
57724
      (void*)&&ZEND_JMP_NULL_SPEC_TMP_LABEL,
57725
      (void*)&&ZEND_JMP_NULL_SPEC_VAR_LABEL,
57726
      (void*)&&ZEND_NULL_LABEL,
57727
      (void*)&&ZEND_JMP_NULL_SPEC_CV_LABEL,
57728
      (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57729
      (void*)&&ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_LABEL,
57730
      (void*)&&ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_LABEL,
57731
      (void*)&&ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_LABEL,
57732
      (void*)&&ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_LABEL,
57733
      (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_LABEL,
57734
      (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_LABEL,
57735
      (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_LABEL,
57736
      (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_LABEL,
57737
      (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_LABEL,
57738
      (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_LABEL,
57739
      (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_LABEL,
57740
      (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_LABEL,
57741
      (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
57742
      (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL,
57743
      (void*)&&ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_LABEL,
57744
      (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
57745
      (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
57746
      (void*)&&ZEND_NULL_LABEL,
57747
      (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
57748
      (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
57749
      (void*)&&ZEND_NULL_LABEL,
57750
      (void*)&&ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_LABEL,
57751
      (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
57752
      (void*)&&ZEND_NULL_LABEL,
57753
      (void*)&&ZEND_NULL_LABEL,
57754
      (void*)&&ZEND_NULL_LABEL,
57755
      (void*)&&ZEND_NULL_LABEL,
57756
      (void*)&&ZEND_NULL_LABEL,
57757
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57758
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57759
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57760
      (void*)&&ZEND_NULL_LABEL,
57761
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57762
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57763
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57764
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57765
      (void*)&&ZEND_NULL_LABEL,
57766
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57767
      (void*)&&ZEND_NULL_LABEL,
57768
      (void*)&&ZEND_NULL_LABEL,
57769
      (void*)&&ZEND_NULL_LABEL,
57770
      (void*)&&ZEND_NULL_LABEL,
57771
      (void*)&&ZEND_NULL_LABEL,
57772
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57773
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57774
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57775
      (void*)&&ZEND_NULL_LABEL,
57776
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57777
      (void*)&&ZEND_NULL_LABEL,
57778
      (void*)&&ZEND_NULL_LABEL,
57779
      (void*)&&ZEND_NULL_LABEL,
57780
      (void*)&&ZEND_NULL_LABEL,
57781
      (void*)&&ZEND_NULL_LABEL,
57782
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57783
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57784
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57785
      (void*)&&ZEND_NULL_LABEL,
57786
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57787
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57788
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57789
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57790
      (void*)&&ZEND_NULL_LABEL,
57791
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57792
      (void*)&&ZEND_NULL_LABEL,
57793
      (void*)&&ZEND_NULL_LABEL,
57794
      (void*)&&ZEND_NULL_LABEL,
57795
      (void*)&&ZEND_NULL_LABEL,
57796
      (void*)&&ZEND_NULL_LABEL,
57797
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57798
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57799
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57800
      (void*)&&ZEND_NULL_LABEL,
57801
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57802
      (void*)&&ZEND_NULL_LABEL,
57803
      (void*)&&ZEND_NULL_LABEL,
57804
      (void*)&&ZEND_NULL_LABEL,
57805
      (void*)&&ZEND_NULL_LABEL,
57806
      (void*)&&ZEND_NULL_LABEL,
57807
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57808
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57809
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57810
      (void*)&&ZEND_NULL_LABEL,
57811
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57812
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57813
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57814
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57815
      (void*)&&ZEND_NULL_LABEL,
57816
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57817
      (void*)&&ZEND_NULL_LABEL,
57818
      (void*)&&ZEND_NULL_LABEL,
57819
      (void*)&&ZEND_NULL_LABEL,
57820
      (void*)&&ZEND_NULL_LABEL,
57821
      (void*)&&ZEND_NULL_LABEL,
57822
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57823
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57824
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57825
      (void*)&&ZEND_NULL_LABEL,
57826
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57827
      (void*)&&ZEND_NULL_LABEL,
57828
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57829
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57830
      (void*)&&ZEND_NULL_LABEL,
57831
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57832
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57833
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57834
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57835
      (void*)&&ZEND_NULL_LABEL,
57836
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57837
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57838
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57839
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57840
      (void*)&&ZEND_NULL_LABEL,
57841
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57842
      (void*)&&ZEND_NULL_LABEL,
57843
      (void*)&&ZEND_NULL_LABEL,
57844
      (void*)&&ZEND_NULL_LABEL,
57845
      (void*)&&ZEND_NULL_LABEL,
57846
      (void*)&&ZEND_NULL_LABEL,
57847
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57848
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57849
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57850
      (void*)&&ZEND_NULL_LABEL,
57851
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57852
      (void*)&&ZEND_NULL_LABEL,
57853
      (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57854
      (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57855
      (void*)&&ZEND_NULL_LABEL,
57856
      (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57857
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57858
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57859
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57860
      (void*)&&ZEND_NULL_LABEL,
57861
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57862
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57863
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57864
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57865
      (void*)&&ZEND_NULL_LABEL,
57866
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57867
      (void*)&&ZEND_NULL_LABEL,
57868
      (void*)&&ZEND_NULL_LABEL,
57869
      (void*)&&ZEND_NULL_LABEL,
57870
      (void*)&&ZEND_NULL_LABEL,
57871
      (void*)&&ZEND_NULL_LABEL,
57872
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57873
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57874
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57875
      (void*)&&ZEND_NULL_LABEL,
57876
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57877
      (void*)&&ZEND_NULL_LABEL,
57878
      (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57879
      (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57880
      (void*)&&ZEND_NULL_LABEL,
57881
      (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57882
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57883
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57884
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57885
      (void*)&&ZEND_NULL_LABEL,
57886
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57887
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57888
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57889
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57890
      (void*)&&ZEND_NULL_LABEL,
57891
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57892
      (void*)&&ZEND_NULL_LABEL,
57893
      (void*)&&ZEND_NULL_LABEL,
57894
      (void*)&&ZEND_NULL_LABEL,
57895
      (void*)&&ZEND_NULL_LABEL,
57896
      (void*)&&ZEND_NULL_LABEL,
57897
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57898
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57899
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57900
      (void*)&&ZEND_NULL_LABEL,
57901
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57902
      (void*)&&ZEND_NULL_LABEL,
57903
      (void*)&&ZEND_NULL_LABEL,
57904
      (void*)&&ZEND_NULL_LABEL,
57905
      (void*)&&ZEND_NULL_LABEL,
57906
      (void*)&&ZEND_NULL_LABEL,
57907
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57908
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57909
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57910
      (void*)&&ZEND_NULL_LABEL,
57911
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57912
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57913
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57914
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57915
      (void*)&&ZEND_NULL_LABEL,
57916
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57917
      (void*)&&ZEND_NULL_LABEL,
57918
      (void*)&&ZEND_NULL_LABEL,
57919
      (void*)&&ZEND_NULL_LABEL,
57920
      (void*)&&ZEND_NULL_LABEL,
57921
      (void*)&&ZEND_NULL_LABEL,
57922
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57923
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57924
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57925
      (void*)&&ZEND_NULL_LABEL,
57926
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57927
      (void*)&&ZEND_NULL_LABEL,
57928
      (void*)&&ZEND_NULL_LABEL,
57929
      (void*)&&ZEND_NULL_LABEL,
57930
      (void*)&&ZEND_NULL_LABEL,
57931
      (void*)&&ZEND_NULL_LABEL,
57932
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57933
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57934
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57935
      (void*)&&ZEND_NULL_LABEL,
57936
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57937
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57938
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57939
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57940
      (void*)&&ZEND_NULL_LABEL,
57941
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57942
      (void*)&&ZEND_NULL_LABEL,
57943
      (void*)&&ZEND_NULL_LABEL,
57944
      (void*)&&ZEND_NULL_LABEL,
57945
      (void*)&&ZEND_NULL_LABEL,
57946
      (void*)&&ZEND_NULL_LABEL,
57947
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57948
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57949
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57950
      (void*)&&ZEND_NULL_LABEL,
57951
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57952
      (void*)&&ZEND_NULL_LABEL,
57953
      (void*)&&ZEND_NULL_LABEL,
57954
      (void*)&&ZEND_NULL_LABEL,
57955
      (void*)&&ZEND_NULL_LABEL,
57956
      (void*)&&ZEND_NULL_LABEL,
57957
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57958
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57959
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57960
      (void*)&&ZEND_NULL_LABEL,
57961
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57962
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57963
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57964
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57965
      (void*)&&ZEND_NULL_LABEL,
57966
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57967
      (void*)&&ZEND_NULL_LABEL,
57968
      (void*)&&ZEND_NULL_LABEL,
57969
      (void*)&&ZEND_NULL_LABEL,
57970
      (void*)&&ZEND_NULL_LABEL,
57971
      (void*)&&ZEND_NULL_LABEL,
57972
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57973
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57974
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57975
      (void*)&&ZEND_NULL_LABEL,
57976
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57977
      (void*)&&ZEND_NULL_LABEL,
57978
      (void*)&&ZEND_NULL_LABEL,
57979
      (void*)&&ZEND_NULL_LABEL,
57980
      (void*)&&ZEND_NULL_LABEL,
57981
      (void*)&&ZEND_NULL_LABEL,
57982
      (void*)&&ZEND_NULL_LABEL,
57983
      (void*)&&ZEND_NULL_LABEL,
57984
      (void*)&&ZEND_NULL_LABEL,
57985
      (void*)&&ZEND_NULL_LABEL,
57986
      (void*)&&ZEND_NULL_LABEL,
57987
      (void*)&&ZEND_NULL_LABEL,
57988
      (void*)&&ZEND_NULL_LABEL,
57989
      (void*)&&ZEND_NULL_LABEL,
57990
      (void*)&&ZEND_NULL_LABEL,
57991
      (void*)&&ZEND_NULL_LABEL,
57992
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57993
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57994
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57995
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57996
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57997
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57998
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57999
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58000
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58001
      (void*)&&ZEND_NULL_LABEL,
58002
      (void*)&&ZEND_NULL_LABEL,
58003
      (void*)&&ZEND_NULL_LABEL,
58004
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58005
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58006
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58007
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58008
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58009
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58010
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58011
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58012
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58013
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58014
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58015
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58016
      (void*)&&ZEND_NULL_LABEL,
58017
      (void*)&&ZEND_NULL_LABEL,
58018
      (void*)&&ZEND_NULL_LABEL,
58019
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58020
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58021
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58022
      (void*)&&ZEND_NULL_LABEL,
58023
      (void*)&&ZEND_NULL_LABEL,
58024
      (void*)&&ZEND_NULL_LABEL,
58025
      (void*)&&ZEND_NULL_LABEL,
58026
      (void*)&&ZEND_NULL_LABEL,
58027
      (void*)&&ZEND_NULL_LABEL,
58028
      (void*)&&ZEND_NULL_LABEL,
58029
      (void*)&&ZEND_NULL_LABEL,
58030
      (void*)&&ZEND_NULL_LABEL,
58031
      (void*)&&ZEND_NULL_LABEL,
58032
      (void*)&&ZEND_NULL_LABEL,
58033
      (void*)&&ZEND_NULL_LABEL,
58034
      (void*)&&ZEND_NULL_LABEL,
58035
      (void*)&&ZEND_NULL_LABEL,
58036
      (void*)&&ZEND_NULL_LABEL,
58037
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58038
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58039
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58040
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58041
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58042
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58043
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58044
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58045
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58046
      (void*)&&ZEND_NULL_LABEL,
58047
      (void*)&&ZEND_NULL_LABEL,
58048
      (void*)&&ZEND_NULL_LABEL,
58049
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58050
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58051
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58052
      (void*)&&ZEND_NULL_LABEL,
58053
      (void*)&&ZEND_NULL_LABEL,
58054
      (void*)&&ZEND_NULL_LABEL,
58055
      (void*)&&ZEND_NULL_LABEL,
58056
      (void*)&&ZEND_NULL_LABEL,
58057
      (void*)&&ZEND_NULL_LABEL,
58058
      (void*)&&ZEND_NULL_LABEL,
58059
      (void*)&&ZEND_NULL_LABEL,
58060
      (void*)&&ZEND_NULL_LABEL,
58061
      (void*)&&ZEND_NULL_LABEL,
58062
      (void*)&&ZEND_NULL_LABEL,
58063
      (void*)&&ZEND_NULL_LABEL,
58064
      (void*)&&ZEND_NULL_LABEL,
58065
      (void*)&&ZEND_NULL_LABEL,
58066
      (void*)&&ZEND_NULL_LABEL,
58067
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58068
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58069
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58070
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58071
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58072
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58073
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58074
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58075
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58076
      (void*)&&ZEND_NULL_LABEL,
58077
      (void*)&&ZEND_NULL_LABEL,
58078
      (void*)&&ZEND_NULL_LABEL,
58079
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58080
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58081
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58082
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58083
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58084
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58085
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58086
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58087
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58088
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58089
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58090
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58091
      (void*)&&ZEND_NULL_LABEL,
58092
      (void*)&&ZEND_NULL_LABEL,
58093
      (void*)&&ZEND_NULL_LABEL,
58094
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58095
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58096
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58097
      (void*)&&ZEND_NULL_LABEL,
58098
      (void*)&&ZEND_NULL_LABEL,
58099
      (void*)&&ZEND_NULL_LABEL,
58100
      (void*)&&ZEND_NULL_LABEL,
58101
      (void*)&&ZEND_NULL_LABEL,
58102
      (void*)&&ZEND_NULL_LABEL,
58103
      (void*)&&ZEND_NULL_LABEL,
58104
      (void*)&&ZEND_NULL_LABEL,
58105
      (void*)&&ZEND_NULL_LABEL,
58106
      (void*)&&ZEND_NULL_LABEL,
58107
      (void*)&&ZEND_NULL_LABEL,
58108
      (void*)&&ZEND_NULL_LABEL,
58109
      (void*)&&ZEND_NULL_LABEL,
58110
      (void*)&&ZEND_NULL_LABEL,
58111
      (void*)&&ZEND_NULL_LABEL,
58112
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58113
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58114
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58115
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58116
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58117
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58118
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58119
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58120
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58121
      (void*)&&ZEND_NULL_LABEL,
58122
      (void*)&&ZEND_NULL_LABEL,
58123
      (void*)&&ZEND_NULL_LABEL,
58124
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58125
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58126
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58127
      (void*)&&ZEND_NULL_LABEL,
58128
      (void*)&&ZEND_NULL_LABEL,
58129
      (void*)&&ZEND_NULL_LABEL,
58130
      (void*)&&ZEND_NULL_LABEL,
58131
      (void*)&&ZEND_NULL_LABEL,
58132
      (void*)&&ZEND_NULL_LABEL,
58133
      (void*)&&ZEND_NULL_LABEL,
58134
      (void*)&&ZEND_NULL_LABEL,
58135
      (void*)&&ZEND_NULL_LABEL,
58136
      (void*)&&ZEND_NULL_LABEL,
58137
      (void*)&&ZEND_NULL_LABEL,
58138
      (void*)&&ZEND_NULL_LABEL,
58139
      (void*)&&ZEND_NULL_LABEL,
58140
      (void*)&&ZEND_NULL_LABEL,
58141
      (void*)&&ZEND_NULL_LABEL,
58142
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58143
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58144
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58145
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58146
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58147
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58148
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58149
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58150
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58151
      (void*)&&ZEND_NULL_LABEL,
58152
      (void*)&&ZEND_NULL_LABEL,
58153
      (void*)&&ZEND_NULL_LABEL,
58154
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58155
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58156
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58157
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58158
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58159
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58160
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58161
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58162
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58163
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58164
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58165
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58166
      (void*)&&ZEND_NULL_LABEL,
58167
      (void*)&&ZEND_NULL_LABEL,
58168
      (void*)&&ZEND_NULL_LABEL,
58169
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58170
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58171
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58172
      (void*)&&ZEND_NULL_LABEL,
58173
      (void*)&&ZEND_NULL_LABEL,
58174
      (void*)&&ZEND_NULL_LABEL,
58175
      (void*)&&ZEND_NULL_LABEL,
58176
      (void*)&&ZEND_NULL_LABEL,
58177
      (void*)&&ZEND_NULL_LABEL,
58178
      (void*)&&ZEND_NULL_LABEL,
58179
      (void*)&&ZEND_NULL_LABEL,
58180
      (void*)&&ZEND_NULL_LABEL,
58181
      (void*)&&ZEND_NULL_LABEL,
58182
      (void*)&&ZEND_NULL_LABEL,
58183
      (void*)&&ZEND_NULL_LABEL,
58184
      (void*)&&ZEND_NULL_LABEL,
58185
      (void*)&&ZEND_NULL_LABEL,
58186
      (void*)&&ZEND_NULL_LABEL,
58187
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58188
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58189
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58190
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58191
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58192
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58193
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58194
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58195
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58196
      (void*)&&ZEND_NULL_LABEL,
58197
      (void*)&&ZEND_NULL_LABEL,
58198
      (void*)&&ZEND_NULL_LABEL,
58199
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58200
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58201
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58202
      (void*)&&ZEND_NULL_LABEL,
58203
      (void*)&&ZEND_NULL_LABEL,
58204
      (void*)&&ZEND_NULL_LABEL,
58205
      (void*)&&ZEND_NULL_LABEL,
58206
      (void*)&&ZEND_NULL_LABEL,
58207
      (void*)&&ZEND_NULL_LABEL,
58208
      (void*)&&ZEND_NULL_LABEL,
58209
      (void*)&&ZEND_NULL_LABEL,
58210
      (void*)&&ZEND_NULL_LABEL,
58211
      (void*)&&ZEND_NULL_LABEL,
58212
      (void*)&&ZEND_NULL_LABEL,
58213
      (void*)&&ZEND_NULL_LABEL,
58214
      (void*)&&ZEND_NULL_LABEL,
58215
      (void*)&&ZEND_NULL_LABEL,
58216
      (void*)&&ZEND_NULL_LABEL,
58217
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58218
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58219
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58220
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58221
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58222
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58223
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58224
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58225
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58226
      (void*)&&ZEND_NULL_LABEL,
58227
      (void*)&&ZEND_NULL_LABEL,
58228
      (void*)&&ZEND_NULL_LABEL,
58229
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58230
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58231
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58232
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58233
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58234
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58235
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58236
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58237
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58238
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58239
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58240
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58241
      (void*)&&ZEND_NULL_LABEL,
58242
      (void*)&&ZEND_NULL_LABEL,
58243
      (void*)&&ZEND_NULL_LABEL,
58244
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58245
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58246
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58247
      (void*)&&ZEND_NULL_LABEL,
58248
      (void*)&&ZEND_NULL_LABEL,
58249
      (void*)&&ZEND_NULL_LABEL,
58250
      (void*)&&ZEND_NULL_LABEL,
58251
      (void*)&&ZEND_NULL_LABEL,
58252
      (void*)&&ZEND_NULL_LABEL,
58253
      (void*)&&ZEND_NULL_LABEL,
58254
      (void*)&&ZEND_NULL_LABEL,
58255
      (void*)&&ZEND_NULL_LABEL,
58256
      (void*)&&ZEND_NULL_LABEL,
58257
      (void*)&&ZEND_NULL_LABEL,
58258
      (void*)&&ZEND_NULL_LABEL,
58259
      (void*)&&ZEND_NULL_LABEL,
58260
      (void*)&&ZEND_NULL_LABEL,
58261
      (void*)&&ZEND_NULL_LABEL,
58262
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58263
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58264
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58265
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58266
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58267
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58268
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58269
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58270
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58271
      (void*)&&ZEND_NULL_LABEL,
58272
      (void*)&&ZEND_NULL_LABEL,
58273
      (void*)&&ZEND_NULL_LABEL,
58274
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58275
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58276
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58277
      (void*)&&ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_LABEL,
58278
      (void*)&&ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58279
      (void*)&&ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58280
      (void*)&&ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_LABEL,
58281
      (void*)&&ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58282
      (void*)&&ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58283
      (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
58284
      (void*)&&ZEND_NULL_LABEL,
58285
      (void*)&&ZEND_NULL_LABEL,
58286
      (void*)&&ZEND_NULL_LABEL,
58287
      (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
58288
      (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
58289
      (void*)&&ZEND_NULL_LABEL,
58290
      (void*)&&ZEND_NULL_LABEL,
58291
      (void*)&&ZEND_NULL_LABEL,
58292
      (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
58293
      (void*)&&ZEND_NULL_LABEL,
58294
      (void*)&&ZEND_NULL_LABEL,
58295
      (void*)&&ZEND_NULL_LABEL,
58296
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58297
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58298
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58299
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58300
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58301
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58302
      (void*)&&ZEND_NULL_LABEL,
58303
      (void*)&&ZEND_NULL_LABEL,
58304
      (void*)&&ZEND_NULL_LABEL,
58305
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58306
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58307
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58308
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58309
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58310
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58311
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58312
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58313
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58314
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58315
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58316
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58317
      (void*)&&ZEND_NULL_LABEL,
58318
      (void*)&&ZEND_NULL_LABEL,
58319
      (void*)&&ZEND_NULL_LABEL,
58320
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58321
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58322
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58323
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58324
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58325
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58326
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58327
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58328
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58329
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58330
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58331
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58332
      (void*)&&ZEND_NULL_LABEL,
58333
      (void*)&&ZEND_NULL_LABEL,
58334
      (void*)&&ZEND_NULL_LABEL,
58335
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58336
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58337
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58338
      (void*)&&ZEND_NULL_LABEL,
58339
      (void*)&&ZEND_NULL_LABEL,
58340
      (void*)&&ZEND_NULL_LABEL,
58341
      (void*)&&ZEND_NULL_LABEL,
58342
      (void*)&&ZEND_NULL_LABEL,
58343
      (void*)&&ZEND_NULL_LABEL,
58344
      (void*)&&ZEND_NULL_LABEL,
58345
      (void*)&&ZEND_NULL_LABEL,
58346
      (void*)&&ZEND_NULL_LABEL,
58347
      (void*)&&ZEND_NULL_LABEL,
58348
      (void*)&&ZEND_NULL_LABEL,
58349
      (void*)&&ZEND_NULL_LABEL,
58350
      (void*)&&ZEND_NULL_LABEL,
58351
      (void*)&&ZEND_NULL_LABEL,
58352
      (void*)&&ZEND_NULL_LABEL,
58353
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58354
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58355
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58356
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58357
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58358
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58359
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58360
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58361
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58362
      (void*)&&ZEND_NULL_LABEL,
58363
      (void*)&&ZEND_NULL_LABEL,
58364
      (void*)&&ZEND_NULL_LABEL,
58365
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58366
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58367
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58368
      (void*)&&ZEND_NULL_LABEL,
58369
      (void*)&&ZEND_NULL_LABEL,
58370
      (void*)&&ZEND_NULL_LABEL,
58371
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58372
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58373
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58374
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58375
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58376
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58377
      (void*)&&ZEND_NULL_LABEL,
58378
      (void*)&&ZEND_NULL_LABEL,
58379
      (void*)&&ZEND_NULL_LABEL,
58380
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58381
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58382
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58383
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58384
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58385
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58386
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58387
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58388
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58389
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58390
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58391
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58392
      (void*)&&ZEND_NULL_LABEL,
58393
      (void*)&&ZEND_NULL_LABEL,
58394
      (void*)&&ZEND_NULL_LABEL,
58395
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58396
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58397
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58398
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58399
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58400
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58401
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58402
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58403
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58404
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58405
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58406
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58407
      (void*)&&ZEND_NULL_LABEL,
58408
      (void*)&&ZEND_NULL_LABEL,
58409
      (void*)&&ZEND_NULL_LABEL,
58410
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58411
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58412
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58413
      (void*)&&ZEND_NULL_LABEL,
58414
      (void*)&&ZEND_NULL_LABEL,
58415
      (void*)&&ZEND_NULL_LABEL,
58416
      (void*)&&ZEND_NULL_LABEL,
58417
      (void*)&&ZEND_NULL_LABEL,
58418
      (void*)&&ZEND_NULL_LABEL,
58419
      (void*)&&ZEND_NULL_LABEL,
58420
      (void*)&&ZEND_NULL_LABEL,
58421
      (void*)&&ZEND_NULL_LABEL,
58422
      (void*)&&ZEND_NULL_LABEL,
58423
      (void*)&&ZEND_NULL_LABEL,
58424
      (void*)&&ZEND_NULL_LABEL,
58425
      (void*)&&ZEND_NULL_LABEL,
58426
      (void*)&&ZEND_NULL_LABEL,
58427
      (void*)&&ZEND_NULL_LABEL,
58428
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58429
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58430
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58431
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58432
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58433
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58434
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58435
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58436
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58437
      (void*)&&ZEND_NULL_LABEL,
58438
      (void*)&&ZEND_NULL_LABEL,
58439
      (void*)&&ZEND_NULL_LABEL,
58440
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58441
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58442
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58443
      (void*)&&ZEND_NULL_LABEL,
58444
      (void*)&&ZEND_NULL_LABEL,
58445
      (void*)&&ZEND_NULL_LABEL,
58446
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58447
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58448
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58449
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58450
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58451
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58452
      (void*)&&ZEND_NULL_LABEL,
58453
      (void*)&&ZEND_NULL_LABEL,
58454
      (void*)&&ZEND_NULL_LABEL,
58455
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58456
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58457
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58458
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58459
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58460
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58461
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58462
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58463
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58464
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58465
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58466
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58467
      (void*)&&ZEND_NULL_LABEL,
58468
      (void*)&&ZEND_NULL_LABEL,
58469
      (void*)&&ZEND_NULL_LABEL,
58470
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58471
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58472
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58473
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58474
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58475
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58476
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58477
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58478
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58479
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58480
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58481
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58482
      (void*)&&ZEND_NULL_LABEL,
58483
      (void*)&&ZEND_NULL_LABEL,
58484
      (void*)&&ZEND_NULL_LABEL,
58485
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58486
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58487
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58488
      (void*)&&ZEND_NULL_LABEL,
58489
      (void*)&&ZEND_NULL_LABEL,
58490
      (void*)&&ZEND_NULL_LABEL,
58491
      (void*)&&ZEND_NULL_LABEL,
58492
      (void*)&&ZEND_NULL_LABEL,
58493
      (void*)&&ZEND_NULL_LABEL,
58494
      (void*)&&ZEND_NULL_LABEL,
58495
      (void*)&&ZEND_NULL_LABEL,
58496
      (void*)&&ZEND_NULL_LABEL,
58497
      (void*)&&ZEND_NULL_LABEL,
58498
      (void*)&&ZEND_NULL_LABEL,
58499
      (void*)&&ZEND_NULL_LABEL,
58500
      (void*)&&ZEND_NULL_LABEL,
58501
      (void*)&&ZEND_NULL_LABEL,
58502
      (void*)&&ZEND_NULL_LABEL,
58503
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58504
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58505
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58506
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58507
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58508
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58509
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58510
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58511
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58512
      (void*)&&ZEND_NULL_LABEL,
58513
      (void*)&&ZEND_NULL_LABEL,
58514
      (void*)&&ZEND_NULL_LABEL,
58515
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58516
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58517
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58518
      (void*)&&ZEND_NULL_LABEL,
58519
      (void*)&&ZEND_NULL_LABEL,
58520
      (void*)&&ZEND_NULL_LABEL,
58521
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58522
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58523
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58524
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58525
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58526
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58527
      (void*)&&ZEND_NULL_LABEL,
58528
      (void*)&&ZEND_NULL_LABEL,
58529
      (void*)&&ZEND_NULL_LABEL,
58530
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58531
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58532
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58533
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58534
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58535
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58536
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58537
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58538
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58539
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58540
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58541
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58542
      (void*)&&ZEND_NULL_LABEL,
58543
      (void*)&&ZEND_NULL_LABEL,
58544
      (void*)&&ZEND_NULL_LABEL,
58545
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58546
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58547
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58548
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58549
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58550
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58551
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58552
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58553
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58554
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58555
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58556
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58557
      (void*)&&ZEND_NULL_LABEL,
58558
      (void*)&&ZEND_NULL_LABEL,
58559
      (void*)&&ZEND_NULL_LABEL,
58560
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58561
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58562
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58563
      (void*)&&ZEND_NULL_LABEL,
58564
      (void*)&&ZEND_NULL_LABEL,
58565
      (void*)&&ZEND_NULL_LABEL,
58566
      (void*)&&ZEND_NULL_LABEL,
58567
      (void*)&&ZEND_NULL_LABEL,
58568
      (void*)&&ZEND_NULL_LABEL,
58569
      (void*)&&ZEND_NULL_LABEL,
58570
      (void*)&&ZEND_NULL_LABEL,
58571
      (void*)&&ZEND_NULL_LABEL,
58572
      (void*)&&ZEND_NULL_LABEL,
58573
      (void*)&&ZEND_NULL_LABEL,
58574
      (void*)&&ZEND_NULL_LABEL,
58575
      (void*)&&ZEND_NULL_LABEL,
58576
      (void*)&&ZEND_NULL_LABEL,
58577
      (void*)&&ZEND_NULL_LABEL,
58578
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58579
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58580
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58581
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58582
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58583
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58584
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58585
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58586
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58587
      (void*)&&ZEND_NULL_LABEL,
58588
      (void*)&&ZEND_NULL_LABEL,
58589
      (void*)&&ZEND_NULL_LABEL,
58590
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58591
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58592
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58593
      (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
58594
      (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
58595
      (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
58596
      (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_LABEL,
58597
      (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
58598
      (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
58599
      (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
58600
      (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_LABEL,
58601
      (void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
58602
      (void*)&&ZEND_POST_INC_LONG_SPEC_CV_LABEL,
58603
      (void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
58604
      (void*)&&ZEND_POST_DEC_LONG_SPEC_CV_LABEL,
58605
      (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_CONST_LABEL,
58606
      (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58607
      (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58608
      (void*)&&ZEND_NULL_LABEL,
58609
      (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58610
      (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
58611
      (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58612
      (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58613
      (void*)&&ZEND_NULL_LABEL,
58614
      (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58615
      (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_CONST_LABEL,
58616
      (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58617
      (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58618
      (void*)&&ZEND_NULL_LABEL,
58619
      (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58620
      (void*)&&ZEND_NULL_LABEL,
58621
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58622
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58623
      (void*)&&ZEND_NULL_LABEL,
58624
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58625
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
58626
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58627
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58628
      (void*)&&ZEND_NULL_LABEL,
58629
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58630
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
58631
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58632
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58633
      (void*)&&ZEND_NULL_LABEL,
58634
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58635
      (void*)&&ZEND_NULL_LABEL,
58636
      (void*)&&ZEND_NULL_LABEL,
58637
      (void*)&&ZEND_NULL_LABEL,
58638
      (void*)&&ZEND_NULL_LABEL,
58639
      (void*)&&ZEND_NULL_LABEL,
58640
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_LABEL,
58641
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58642
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58643
      (void*)&&ZEND_NULL_LABEL,
58644
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58645
      (void*)&&ZEND_NULL_LABEL,
58646
      (void*)&&ZEND_NULL_LABEL,
58647
      (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_VAR_LABEL,
58648
      (void*)&&ZEND_NULL_LABEL,
58649
      (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_CV_LABEL,
58650
      (void*)&&ZEND_NULL_LABEL,
58651
      (void*)&&ZEND_NULL_LABEL,
58652
      (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_LABEL,
58653
      (void*)&&ZEND_NULL_LABEL,
58654
      (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_LABEL,
58655
      (void*)&&ZEND_SEND_VAL_SIMPLE_SPEC_CONST_LABEL,
58656
      (void*)&&ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_LABEL,
58657
      (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
58658
      (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_LABEL,
58659
      (void*)&&ZEND_NULL_LABEL
58660
    };
58661
    zend_opcode_handlers = (const void **) labels;
58662
    zend_handlers_count = sizeof(labels) / sizeof(void*);
58663
    memset(&hybrid_halt_op, 0, sizeof(hybrid_halt_op));
58664
    hybrid_halt_op.handler = (void*)&&HYBRID_HALT_LABEL;
58665
#ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
58666
    memset(vm_stack_data.hybrid_jit_red_zone, 0, ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE);
58667
#endif
58668
    if (zend_touch_vm_stack_data) {
58669
      zend_touch_vm_stack_data(&vm_stack_data);
58670
    }
58671
    goto HYBRID_HALT_LABEL;
58672
  }
58673
#endif
58674
58675
83.1k
  LOAD_OPLINE();
58676
83.1k
  ZEND_VM_LOOP_INTERRUPT_CHECK();
58677
58678
83.1k
#ifdef ZEND_CHECK_STACK_LIMIT
58679
83.1k
  if (UNEXPECTED(zend_call_stack_overflowed(EG(stack_limit)))) {
58680
2
    zend_call_stack_size_error();
58681
    /* No opline was executed before exception */
58682
2
    EG(opline_before_exception) = NULL;
58683
2
    LOAD_OPLINE();
58684
    /* Fall through to handle exception below. */
58685
2
  }
58686
83.1k
#endif /* ZEND_CHECK_STACK_LIMIT */
58687
58688
3.78M
  while (1) {
58689
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
58690
    HYBRID_SWITCH() {
58691
#else /* ZEND_VM_KIND != ZEND_VM_KIND_HYBRID */
58692
#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
58693
    ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58694
    if (UNEXPECTED(!OPLINE)) {
58695
#else
58696
3.76M
    opline = ((opcode_handler_t)opline->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58697
3.76M
    if (UNEXPECTED(((uintptr_t)opline & ZEND_VM_ENTER_BIT))) {
58698
111k
#endif
58699
111k
#endif /* ZEND_VM_KIND != ZEND_VM_KIND_HYBRID */
58700
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
58701
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC):
58702
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
58703
        ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58704
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
58705
        HYBRID_BREAK();
58706
      HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC):
58707
        VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC)
58708
        ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58709
        VM_TRACE_OP_END(ZEND_PRE_INC_STATIC_PROP_SPEC)
58710
        HYBRID_BREAK();
58711
      HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC):
58712
        VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC)
58713
        ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58714
        VM_TRACE_OP_END(ZEND_POST_INC_STATIC_PROP_SPEC)
58715
        HYBRID_BREAK();
58716
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC):
58717
        VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC)
58718
        ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58719
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_R_SPEC)
58720
        HYBRID_BREAK();
58721
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_W_SPEC):
58722
        VM_TRACE(ZEND_FETCH_STATIC_PROP_W_SPEC)
58723
        ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58724
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_W_SPEC)
58725
        HYBRID_BREAK();
58726
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_RW_SPEC):
58727
        VM_TRACE(ZEND_FETCH_STATIC_PROP_RW_SPEC)
58728
        ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58729
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_RW_SPEC)
58730
        HYBRID_BREAK();
58731
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC):
58732
        VM_TRACE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
58733
        ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58734
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
58735
        HYBRID_BREAK();
58736
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC):
58737
        VM_TRACE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
58738
        ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58739
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
58740
        HYBRID_BREAK();
58741
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_IS_SPEC):
58742
        VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC)
58743
        ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58744
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_IS_SPEC)
58745
        HYBRID_BREAK();
58746
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST):
58747
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
58748
        ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58749
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
58750
        HYBRID_BREAK();
58751
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP):
58752
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
58753
        ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58754
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
58755
        HYBRID_BREAK();
58756
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR):
58757
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
58758
        ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58759
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
58760
        HYBRID_BREAK();
58761
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV):
58762
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
58763
        ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58764
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
58765
        HYBRID_BREAK();
58766
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC):
58767
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
58768
        ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58769
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
58770
        HYBRID_BREAK();
58771
zend_leave_helper_SPEC_LABEL:
58772
{
58773
  zend_execute_data *old_execute_data;
58774
  uint32_t call_info = EX_CALL_INFO();
58775
  SAVE_OPLINE();
58776
58777
  if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) {
58778
    EG(current_execute_data) = EX(prev_execute_data);
58779
    i_free_compiled_variables(execute_data);
58780
58781
#ifdef ZEND_PREFER_RELOAD
58782
    call_info = EX_CALL_INFO();
58783
#endif
58784
    if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
58785
      OBJ_RELEASE(Z_OBJ(execute_data->This));
58786
    } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58787
      OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58788
    }
58789
    EG(vm_stack_top) = (zval*)execute_data;
58790
    execute_data = EX(prev_execute_data);
58791
58792
    if (UNEXPECTED(EG(exception) != NULL)) {
58793
      zend_rethrow_exception(execute_data);
58794
      HANDLE_EXCEPTION_LEAVE();
58795
    }
58796
58797
    LOAD_NEXT_OPLINE();
58798
    ZEND_VM_LEAVE();
58799
  } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
58800
    EG(current_execute_data) = EX(prev_execute_data);
58801
    i_free_compiled_variables(execute_data);
58802
58803
#ifdef ZEND_PREFER_RELOAD
58804
    call_info = EX_CALL_INFO();
58805
#endif
58806
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58807
      zend_clean_and_cache_symbol_table(EX(symbol_table));
58808
    }
58809
58810
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
58811
      zend_free_extra_named_params(EX(extra_named_params));
58812
    }
58813
58814
    /* Free extra args before releasing the closure,
58815
     * as that may free the op_array. */
58816
    zend_vm_stack_free_extra_args_ex(call_info, execute_data);
58817
58818
    if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
58819
      OBJ_RELEASE(Z_OBJ(execute_data->This));
58820
    } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58821
      OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58822
    }
58823
58824
    old_execute_data = execute_data;
58825
    execute_data = EX(prev_execute_data);
58826
    zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
58827
58828
    if (UNEXPECTED(EG(exception) != NULL)) {
58829
      zend_rethrow_exception(execute_data);
58830
      HANDLE_EXCEPTION_LEAVE();
58831
    }
58832
58833
    LOAD_NEXT_OPLINE();
58834
    ZEND_VM_LEAVE();
58835
  } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
58836
    if (EX(func)->op_array.last_var > 0) {
58837
      zend_detach_symbol_table(execute_data);
58838
      call_info |= ZEND_CALL_NEEDS_REATTACH;
58839
    }
58840
    zend_destroy_static_vars(&EX(func)->op_array);
58841
    destroy_op_array(&EX(func)->op_array);
58842
    efree_size(EX(func), sizeof(zend_op_array));
58843
    old_execute_data = execute_data;
58844
    execute_data = EG(current_execute_data) = EX(prev_execute_data);
58845
    zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
58846
58847
    if (call_info & ZEND_CALL_NEEDS_REATTACH) {
58848
      if (EX(func)->op_array.last_var > 0) {
58849
        zend_attach_symbol_table(execute_data);
58850
      } else {
58851
        ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
58852
      }
58853
    }
58854
    if (UNEXPECTED(EG(exception) != NULL)) {
58855
      zend_rethrow_exception(execute_data);
58856
      HANDLE_EXCEPTION_LEAVE();
58857
    }
58858
58859
    LOAD_NEXT_OPLINE();
58860
    ZEND_VM_LEAVE();
58861
  } else {
58862
    if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
58863
      EG(current_execute_data) = EX(prev_execute_data);
58864
      i_free_compiled_variables(execute_data);
58865
#ifdef ZEND_PREFER_RELOAD
58866
      call_info = EX_CALL_INFO();
58867
#endif
58868
      if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
58869
        if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58870
          zend_clean_and_cache_symbol_table(EX(symbol_table));
58871
        }
58872
        zend_vm_stack_free_extra_args_ex(call_info, execute_data);
58873
        if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
58874
          zend_free_extra_named_params(EX(extra_named_params));
58875
        }
58876
      }
58877
      if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58878
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58879
      }
58880
      ZEND_VM_RETURN();
58881
    } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
58882
      zend_array *symbol_table = EX(symbol_table);
58883
58884
      if (EX(func)->op_array.last_var > 0) {
58885
        zend_detach_symbol_table(execute_data);
58886
        call_info |= ZEND_CALL_NEEDS_REATTACH;
58887
      }
58888
      if (call_info & ZEND_CALL_NEEDS_REATTACH) {
58889
        old_execute_data = EX(prev_execute_data);
58890
        while (old_execute_data) {
58891
          if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58892
            if (old_execute_data->symbol_table == symbol_table) {
58893
              if (old_execute_data->func->op_array.last_var > 0) {
58894
                zend_attach_symbol_table(old_execute_data);
58895
              } else {
58896
                ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
58897
              }
58898
            }
58899
            break;
58900
          }
58901
          old_execute_data = old_execute_data->prev_execute_data;
58902
        }
58903
      }
58904
      EG(current_execute_data) = EX(prev_execute_data);
58905
      ZEND_VM_RETURN();
58906
    }
58907
  }
58908
}
58909
58910
      HYBRID_CASE(ZEND_JMP_SPEC):
58911
        VM_TRACE(ZEND_JMP_SPEC)
58912
        ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58913
        VM_TRACE_OP_END(ZEND_JMP_SPEC)
58914
        HYBRID_BREAK();
58915
      HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED):
58916
        VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
58917
        ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58918
        VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
58919
        HYBRID_BREAK();
58920
      HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_USED):
58921
        VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_USED)
58922
        ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58923
        VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_USED)
58924
        HYBRID_BREAK();
58925
      HYBRID_CASE(ZEND_DO_ICALL_SPEC_OBSERVER):
58926
        VM_TRACE(ZEND_DO_ICALL_SPEC_OBSERVER)
58927
        ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58928
        VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_OBSERVER)
58929
        HYBRID_BREAK();
58930
      HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED):
58931
        VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
58932
        ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58933
        VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
58934
        HYBRID_BREAK();
58935
      HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_USED):
58936
        VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED)
58937
        ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58938
        VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_USED)
58939
        HYBRID_BREAK();
58940
      HYBRID_CASE(ZEND_DO_UCALL_SPEC_OBSERVER):
58941
        VM_TRACE(ZEND_DO_UCALL_SPEC_OBSERVER)
58942
        ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58943
        VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_OBSERVER)
58944
        HYBRID_BREAK();
58945
      HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED):
58946
        VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
58947
        ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58948
        VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
58949
        HYBRID_BREAK();
58950
      HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED):
58951
        VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
58952
        ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58953
        VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
58954
        HYBRID_BREAK();
58955
      HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER):
58956
        VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
58957
        ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58958
        VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
58959
        HYBRID_BREAK();
58960
      HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED):
58961
        VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
58962
        ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58963
        VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
58964
        HYBRID_BREAK();
58965
      HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_USED):
58966
        VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED)
58967
        ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58968
        VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_USED)
58969
        HYBRID_BREAK();
58970
      HYBRID_CASE(ZEND_DO_FCALL_SPEC_OBSERVER):
58971
        VM_TRACE(ZEND_DO_FCALL_SPEC_OBSERVER)
58972
        ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58973
        VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_OBSERVER)
58974
        HYBRID_BREAK();
58975
      HYBRID_CASE(ZEND_GENERATOR_CREATE_SPEC):
58976
        VM_TRACE(ZEND_GENERATOR_CREATE_SPEC)
58977
        ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58978
        VM_TRACE_OP_END(ZEND_GENERATOR_CREATE_SPEC)
58979
        HYBRID_BREAK();
58980
      HYBRID_CASE(ZEND_SEND_UNPACK_SPEC):
58981
        VM_TRACE(ZEND_SEND_UNPACK_SPEC)
58982
        ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58983
        VM_TRACE_OP_END(ZEND_SEND_UNPACK_SPEC)
58984
        HYBRID_BREAK();
58985
      HYBRID_CASE(ZEND_SEND_ARRAY_SPEC):
58986
        VM_TRACE(ZEND_SEND_ARRAY_SPEC)
58987
        ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58988
        VM_TRACE_OP_END(ZEND_SEND_ARRAY_SPEC)
58989
        HYBRID_BREAK();
58990
      HYBRID_CASE(ZEND_RECV_NOTYPE_SPEC):
58991
        VM_TRACE(ZEND_RECV_NOTYPE_SPEC)
58992
        ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58993
        VM_TRACE_OP_END(ZEND_RECV_NOTYPE_SPEC)
58994
        HYBRID_BREAK();
58995
      HYBRID_CASE(ZEND_ADD_ARRAY_UNPACK_SPEC):
58996
        VM_TRACE(ZEND_ADD_ARRAY_UNPACK_SPEC)
58997
        ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58998
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_UNPACK_SPEC)
58999
        HYBRID_BREAK();
59000
      HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC):
59001
        VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC)
59002
        ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59003
        VM_TRACE_OP_END(ZEND_UNSET_STATIC_PROP_SPEC)
59004
        HYBRID_BREAK();
59005
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC):
59006
        VM_TRACE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
59007
        ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59008
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
59009
        HYBRID_BREAK();
59010
      HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC):
59011
        VM_TRACE(ZEND_BEGIN_SILENCE_SPEC)
59012
        ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59013
        VM_TRACE_OP_END(ZEND_BEGIN_SILENCE_SPEC)
59014
        HYBRID_BREAK();
59015
      HYBRID_CASE(ZEND_EXT_STMT_SPEC):
59016
        VM_TRACE(ZEND_EXT_STMT_SPEC)
59017
        ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59018
        VM_TRACE_OP_END(ZEND_EXT_STMT_SPEC)
59019
        HYBRID_BREAK();
59020
      HYBRID_CASE(ZEND_EXT_FCALL_BEGIN_SPEC):
59021
        VM_TRACE(ZEND_EXT_FCALL_BEGIN_SPEC)
59022
        ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59023
        VM_TRACE_OP_END(ZEND_EXT_FCALL_BEGIN_SPEC)
59024
        HYBRID_BREAK();
59025
      HYBRID_CASE(ZEND_EXT_FCALL_END_SPEC):
59026
        VM_TRACE(ZEND_EXT_FCALL_END_SPEC)
59027
        ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59028
        VM_TRACE_OP_END(ZEND_EXT_FCALL_END_SPEC)
59029
        HYBRID_BREAK();
59030
      HYBRID_CASE(ZEND_DECLARE_ANON_CLASS_SPEC):
59031
        VM_TRACE(ZEND_DECLARE_ANON_CLASS_SPEC)
59032
        ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59033
        VM_TRACE_OP_END(ZEND_DECLARE_ANON_CLASS_SPEC)
59034
        HYBRID_BREAK();
59035
      HYBRID_CASE(ZEND_DECLARE_FUNCTION_SPEC):
59036
        VM_TRACE(ZEND_DECLARE_FUNCTION_SPEC)
59037
        ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59038
        VM_TRACE_OP_END(ZEND_DECLARE_FUNCTION_SPEC)
59039
        HYBRID_BREAK();
59040
      HYBRID_CASE(ZEND_TICKS_SPEC):
59041
        VM_TRACE(ZEND_TICKS_SPEC)
59042
        ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59043
        VM_TRACE_OP_END(ZEND_TICKS_SPEC)
59044
        HYBRID_BREAK();
59045
      HYBRID_CASE(ZEND_EXT_NOP_SPEC):
59046
        VM_TRACE(ZEND_EXT_NOP_SPEC)
59047
        ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59048
        VM_TRACE_OP_END(ZEND_EXT_NOP_SPEC)
59049
        HYBRID_BREAK();
59050
      HYBRID_CASE(ZEND_NOP_SPEC):
59051
        VM_TRACE(ZEND_NOP_SPEC)
59052
        ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59053
        VM_TRACE_OP_END(ZEND_NOP_SPEC)
59054
        HYBRID_BREAK();
59055
      HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC):
59056
        VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC)
59057
        ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59058
        VM_TRACE_OP_END(ZEND_HANDLE_EXCEPTION_SPEC)
59059
        HYBRID_BREAK();
59060
      HYBRID_CASE(ZEND_USER_OPCODE_SPEC):
59061
        VM_TRACE(ZEND_USER_OPCODE_SPEC)
59062
        ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59063
        VM_TRACE_OP_END(ZEND_USER_OPCODE_SPEC)
59064
        HYBRID_BREAK();
59065
      HYBRID_CASE(ZEND_DISCARD_EXCEPTION_SPEC):
59066
        VM_TRACE(ZEND_DISCARD_EXCEPTION_SPEC)
59067
        ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59068
        VM_TRACE_OP_END(ZEND_DISCARD_EXCEPTION_SPEC)
59069
        HYBRID_BREAK();
59070
      HYBRID_CASE(ZEND_FAST_CALL_SPEC):
59071
        VM_TRACE(ZEND_FAST_CALL_SPEC)
59072
        ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59073
        VM_TRACE_OP_END(ZEND_FAST_CALL_SPEC)
59074
        HYBRID_BREAK();
59075
      HYBRID_CASE(ZEND_FAST_RET_SPEC):
59076
        VM_TRACE(ZEND_FAST_RET_SPEC)
59077
        ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59078
        VM_TRACE_OP_END(ZEND_FAST_RET_SPEC)
59079
        HYBRID_BREAK();
59080
      HYBRID_CASE(ZEND_ASSERT_CHECK_SPEC):
59081
        VM_TRACE(ZEND_ASSERT_CHECK_SPEC)
59082
        ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59083
        VM_TRACE_OP_END(ZEND_ASSERT_CHECK_SPEC)
59084
        HYBRID_BREAK();
59085
      HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC):
59086
        VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC)
59087
        ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59088
        VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC)
59089
        HYBRID_BREAK();
59090
      HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER):
59091
        VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
59092
        ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59093
        VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
59094
        HYBRID_BREAK();
59095
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC):
59096
        VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC)
59097
        ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59098
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC)
59099
        HYBRID_BREAK();
59100
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER):
59101
        VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER)
59102
        ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59103
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER)
59104
        HYBRID_BREAK();
59105
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC):
59106
        VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC)
59107
        ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59108
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC)
59109
        HYBRID_BREAK();
59110
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER):
59111
        VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER)
59112
        ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59113
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER)
59114
        HYBRID_BREAK();
59115
      HYBRID_CASE(ZEND_JMP_FORWARD_SPEC):
59116
        VM_TRACE(ZEND_JMP_FORWARD_SPEC)
59117
        ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59118
        VM_TRACE_OP_END(ZEND_JMP_FORWARD_SPEC)
59119
        HYBRID_BREAK();
59120
      HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST):
59121
        VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
59122
        ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59123
        VM_TRACE_OP_END(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
59124
        HYBRID_BREAK();
59125
      HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST):
59126
        VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
59127
        ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59128
        VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
59129
        HYBRID_BREAK();
59130
      HYBRID_CASE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST):
59131
        VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
59132
        ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59133
        VM_TRACE_OP_END(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
59134
        HYBRID_BREAK();
59135
      HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST):
59136
        VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST)
59137
        ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59138
        VM_TRACE_OP_END(ZEND_INIT_FCALL_SPEC_CONST)
59139
        HYBRID_BREAK();
59140
      HYBRID_CASE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST):
59141
        VM_TRACE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
59142
        ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59143
        VM_TRACE_OP_END(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
59144
        HYBRID_BREAK();
59145
      HYBRID_CASE(ZEND_RECV_INIT_SPEC_CONST):
59146
        VM_TRACE(ZEND_RECV_INIT_SPEC_CONST)
59147
        ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59148
        VM_TRACE_OP_END(ZEND_RECV_INIT_SPEC_CONST)
59149
        HYBRID_BREAK();
59150
      HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR):
59151
        VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
59152
        ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59153
        VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
59154
        HYBRID_BREAK();
59155
      HYBRID_CASE(ZEND_RECV_SPEC_UNUSED):
59156
        VM_TRACE(ZEND_RECV_SPEC_UNUSED)
59157
        ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59158
        VM_TRACE_OP_END(ZEND_RECV_SPEC_UNUSED)
59159
        HYBRID_BREAK();
59160
      HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC_UNUSED):
59161
        VM_TRACE(ZEND_RECV_VARIADIC_SPEC_UNUSED)
59162
        ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59163
        VM_TRACE_OP_END(ZEND_RECV_VARIADIC_SPEC_UNUSED)
59164
        HYBRID_BREAK();
59165
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED):
59166
        VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
59167
        ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59168
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
59169
        HYBRID_BREAK();
59170
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER):
59171
        VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER)
59172
        ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59173
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER)
59174
        HYBRID_BREAK();
59175
      HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV):
59176
        VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
59177
        ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59178
        VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
59179
        HYBRID_BREAK();
59180
      HYBRID_CASE(ZEND_BW_NOT_SPEC_CONST):
59181
        VM_TRACE(ZEND_BW_NOT_SPEC_CONST)
59182
        ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59183
        VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_CONST)
59184
        HYBRID_BREAK();
59185
      HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CONST):
59186
        VM_TRACE(ZEND_BOOL_NOT_SPEC_CONST)
59187
        ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59188
        VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CONST)
59189
        HYBRID_BREAK();
59190
      HYBRID_CASE(ZEND_ECHO_SPEC_CONST):
59191
        VM_TRACE(ZEND_ECHO_SPEC_CONST)
59192
        ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59193
        VM_TRACE_OP_END(ZEND_ECHO_SPEC_CONST)
59194
        HYBRID_BREAK();
59195
      HYBRID_CASE(ZEND_JMPZ_SPEC_CONST):
59196
        VM_TRACE(ZEND_JMPZ_SPEC_CONST)
59197
        ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59198
        VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CONST)
59199
        HYBRID_BREAK();
59200
      HYBRID_CASE(ZEND_JMPNZ_SPEC_CONST):
59201
        VM_TRACE(ZEND_JMPNZ_SPEC_CONST)
59202
        ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59203
        VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CONST)
59204
        HYBRID_BREAK();
59205
      HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CONST):
59206
        VM_TRACE(ZEND_JMPZ_EX_SPEC_CONST)
59207
        ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59208
        VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CONST)
59209
        HYBRID_BREAK();
59210
      HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CONST):
59211
        VM_TRACE(ZEND_JMPNZ_EX_SPEC_CONST)
59212
        ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59213
        VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CONST)
59214
        HYBRID_BREAK();
59215
      HYBRID_CASE(ZEND_RETURN_SPEC_CONST):
59216
        VM_TRACE(ZEND_RETURN_SPEC_CONST)
59217
{
59218
  USE_OPLINE
59219
  zval *retval_ptr;
59220
  zval *return_value;
59221
59222
  retval_ptr = RT_CONSTANT(opline, opline->op1);
59223
  return_value = EX(return_value);
59224
59225
  if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59226
    SAVE_OPLINE();
59227
    retval_ptr = ZVAL_UNDEFINED_OP1();
59228
    if (return_value) {
59229
      ZVAL_NULL(return_value);
59230
    }
59231
  } else if (!return_value) {
59232
    if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
59233
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59234
        SAVE_OPLINE();
59235
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
59236
      }
59237
    }
59238
  } else {
59239
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
59240
      ZVAL_COPY_VALUE(return_value, retval_ptr);
59241
      if (IS_CONST == IS_CONST) {
59242
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59243
          Z_ADDREF_P(return_value);
59244
        }
59245
      }
59246
    } else if (IS_CONST == IS_CV) {
59247
      do {
59248
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59249
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59250
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59251
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59252
              ZVAL_COPY_VALUE(return_value, retval_ptr);
59253
              if (GC_MAY_LEAK(ref)) {
59254
                SAVE_OPLINE();
59255
                gc_possible_root(ref);
59256
              }
59257
              ZVAL_NULL(retval_ptr);
59258
              break;
59259
            } else {
59260
              Z_ADDREF_P(retval_ptr);
59261
            }
59262
          } else {
59263
            retval_ptr = Z_REFVAL_P(retval_ptr);
59264
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59265
              Z_ADDREF_P(retval_ptr);
59266
            }
59267
          }
59268
        }
59269
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59270
      } while (0);
59271
    } else /* if (IS_CONST == IS_VAR) */ {
59272
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59273
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59274
59275
        retval_ptr = Z_REFVAL_P(retval_ptr);
59276
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59277
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59278
          efree_size(ref, sizeof(zend_reference));
59279
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59280
          Z_ADDREF_P(retval_ptr);
59281
        }
59282
      } else {
59283
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59284
      }
59285
    }
59286
  }
59287
59288
59289
59290
  goto zend_leave_helper_SPEC_LABEL;
59291
}
59292
59293
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_CONST)
59294
      HYBRID_CASE(ZEND_RETURN_SPEC_OBSERVER):
59295
        VM_TRACE(ZEND_RETURN_SPEC_OBSERVER)
59296
{
59297
  USE_OPLINE
59298
  zval *retval_ptr;
59299
  zval *return_value;
59300
  zval observer_retval;
59301
59302
  retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
59303
  return_value = EX(return_value);
59304
  if (!return_value) { return_value = &observer_retval; };
59305
  if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59306
    SAVE_OPLINE();
59307
    retval_ptr = ZVAL_UNDEFINED_OP1();
59308
    if (return_value) {
59309
      ZVAL_NULL(return_value);
59310
    }
59311
  } else if (!return_value) {
59312
    if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
59313
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59314
        SAVE_OPLINE();
59315
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
59316
      }
59317
    }
59318
  } else {
59319
    if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
59320
      ZVAL_COPY_VALUE(return_value, retval_ptr);
59321
      if (opline->op1_type == IS_CONST) {
59322
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59323
          Z_ADDREF_P(return_value);
59324
        }
59325
      }
59326
    } else if (opline->op1_type == IS_CV) {
59327
      do {
59328
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59329
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59330
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59331
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59332
              ZVAL_COPY_VALUE(return_value, retval_ptr);
59333
              if (GC_MAY_LEAK(ref)) {
59334
                SAVE_OPLINE();
59335
                gc_possible_root(ref);
59336
              }
59337
              ZVAL_NULL(retval_ptr);
59338
              break;
59339
            } else {
59340
              Z_ADDREF_P(retval_ptr);
59341
            }
59342
          } else {
59343
            retval_ptr = Z_REFVAL_P(retval_ptr);
59344
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59345
              Z_ADDREF_P(retval_ptr);
59346
            }
59347
          }
59348
        }
59349
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59350
      } while (0);
59351
    } else /* if (opline->op1_type == IS_VAR) */ {
59352
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59353
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59354
59355
        retval_ptr = Z_REFVAL_P(retval_ptr);
59356
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59357
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59358
          efree_size(ref, sizeof(zend_reference));
59359
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59360
          Z_ADDREF_P(retval_ptr);
59361
        }
59362
      } else {
59363
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59364
      }
59365
    }
59366
  }
59367
  SAVE_OPLINE();
59368
  zend_observer_fcall_end(execute_data, return_value);
59369
  if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
59370
  goto zend_leave_helper_SPEC_LABEL;
59371
}
59372
59373
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_OBSERVER)
59374
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CONST):
59375
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST)
59376
        ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59377
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CONST)
59378
        HYBRID_BREAK();
59379
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_OBSERVER):
59380
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
59381
        ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59382
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
59383
        HYBRID_BREAK();
59384
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST):
59385
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST)
59386
        ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59387
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CONST)
59388
        HYBRID_BREAK();
59389
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER):
59390
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
59391
        ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59392
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
59393
        HYBRID_BREAK();
59394
      HYBRID_CASE(ZEND_THROW_SPEC_CONST):
59395
        VM_TRACE(ZEND_THROW_SPEC_CONST)
59396
        ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59397
        VM_TRACE_OP_END(ZEND_THROW_SPEC_CONST)
59398
        HYBRID_BREAK();
59399
      HYBRID_CASE(ZEND_CATCH_SPEC_CONST):
59400
        VM_TRACE(ZEND_CATCH_SPEC_CONST)
59401
        ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59402
        VM_TRACE_OP_END(ZEND_CATCH_SPEC_CONST)
59403
        HYBRID_BREAK();
59404
      HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST):
59405
        VM_TRACE(ZEND_SEND_USER_SPEC_CONST)
59406
        ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59407
        VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST)
59408
        HYBRID_BREAK();
59409
      HYBRID_CASE(ZEND_BOOL_SPEC_CONST):
59410
        VM_TRACE(ZEND_BOOL_SPEC_CONST)
59411
        ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59412
        VM_TRACE_OP_END(ZEND_BOOL_SPEC_CONST)
59413
        HYBRID_BREAK();
59414
      HYBRID_CASE(ZEND_CLONE_SPEC_CONST):
59415
        VM_TRACE(ZEND_CLONE_SPEC_CONST)
59416
        ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59417
        VM_TRACE_OP_END(ZEND_CLONE_SPEC_CONST)
59418
        HYBRID_BREAK();
59419
      HYBRID_CASE(ZEND_CAST_SPEC_CONST):
59420
        VM_TRACE(ZEND_CAST_SPEC_CONST)
59421
        ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59422
        VM_TRACE_OP_END(ZEND_CAST_SPEC_CONST)
59423
        HYBRID_BREAK();
59424
      HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST):
59425
        VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
59426
        ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59427
        VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
59428
        HYBRID_BREAK();
59429
      HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER):
59430
        VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
59431
        ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59432
        VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
59433
        HYBRID_BREAK();
59434
      HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CONST):
59435
        VM_TRACE(ZEND_FE_RESET_R_SPEC_CONST)
59436
        ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59437
        VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CONST)
59438
        HYBRID_BREAK();
59439
      HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CONST):
59440
        VM_TRACE(ZEND_FE_RESET_RW_SPEC_CONST)
59441
        ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59442
        VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CONST)
59443
        HYBRID_BREAK();
59444
      HYBRID_CASE(ZEND_JMP_SET_SPEC_CONST):
59445
        VM_TRACE(ZEND_JMP_SET_SPEC_CONST)
59446
        ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59447
        VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CONST)
59448
        HYBRID_BREAK();
59449
      HYBRID_CASE(ZEND_COALESCE_SPEC_CONST):
59450
        VM_TRACE(ZEND_COALESCE_SPEC_CONST)
59451
        ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59452
        VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CONST)
59453
        HYBRID_BREAK();
59454
      HYBRID_CASE(ZEND_JMP_NULL_SPEC_CONST):
59455
        VM_TRACE(ZEND_JMP_NULL_SPEC_CONST)
59456
        ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59457
        VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CONST)
59458
        HYBRID_BREAK();
59459
      HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CONST):
59460
        VM_TRACE(ZEND_QM_ASSIGN_SPEC_CONST)
59461
        ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59462
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CONST)
59463
        HYBRID_BREAK();
59464
      HYBRID_CASE(ZEND_DECLARE_CLASS_SPEC_CONST):
59465
        VM_TRACE(ZEND_DECLARE_CLASS_SPEC_CONST)
59466
        ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59467
        VM_TRACE_OP_END(ZEND_DECLARE_CLASS_SPEC_CONST)
59468
        HYBRID_BREAK();
59469
      HYBRID_CASE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST):
59470
        VM_TRACE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
59471
        ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59472
        VM_TRACE_OP_END(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
59473
        HYBRID_BREAK();
59474
      HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CONST):
59475
        VM_TRACE(ZEND_YIELD_FROM_SPEC_CONST)
59476
        ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59477
        VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CONST)
59478
        HYBRID_BREAK();
59479
      HYBRID_CASE(ZEND_STRLEN_SPEC_CONST):
59480
        VM_TRACE(ZEND_STRLEN_SPEC_CONST)
59481
        ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59482
        VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CONST)
59483
        HYBRID_BREAK();
59484
      HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CONST):
59485
        VM_TRACE(ZEND_TYPE_CHECK_SPEC_CONST)
59486
        ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59487
        VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST)
59488
        HYBRID_BREAK();
59489
      HYBRID_CASE(ZEND_DEFINED_SPEC_CONST):
59490
        VM_TRACE(ZEND_DEFINED_SPEC_CONST)
59491
        ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59492
        VM_TRACE_OP_END(ZEND_DEFINED_SPEC_CONST)
59493
        HYBRID_BREAK();
59494
      HYBRID_CASE(ZEND_JMP_FRAMELESS_SPEC_CONST):
59495
        VM_TRACE(ZEND_JMP_FRAMELESS_SPEC_CONST)
59496
        ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59497
        VM_TRACE_OP_END(ZEND_JMP_FRAMELESS_SPEC_CONST)
59498
        HYBRID_BREAK();
59499
      HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_CONST):
59500
        VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
59501
        ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59502
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
59503
        HYBRID_BREAK();
59504
      HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST):
59505
        VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
59506
        ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59507
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
59508
        HYBRID_BREAK();
59509
      HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST):
59510
        VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
59511
        ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59512
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
59513
        HYBRID_BREAK();
59514
      HYBRID_CASE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST):
59515
        VM_TRACE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
59516
        ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59517
        VM_TRACE_OP_END(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
59518
        HYBRID_BREAK();
59519
      HYBRID_CASE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST):
59520
        VM_TRACE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
59521
        ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59522
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
59523
        HYBRID_BREAK();
59524
      HYBRID_CASE(ZEND_ADD_SPEC_CONST_CONST):
59525
        VM_TRACE(ZEND_ADD_SPEC_CONST_CONST)
59526
        ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59527
        VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_CONST)
59528
        HYBRID_BREAK();
59529
      HYBRID_CASE(ZEND_SUB_SPEC_CONST_CONST):
59530
        VM_TRACE(ZEND_SUB_SPEC_CONST_CONST)
59531
        ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59532
        VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_CONST)
59533
        HYBRID_BREAK();
59534
      HYBRID_CASE(ZEND_MUL_SPEC_CONST_CONST):
59535
        VM_TRACE(ZEND_MUL_SPEC_CONST_CONST)
59536
        ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59537
        VM_TRACE_OP_END(ZEND_MUL_SPEC_CONST_CONST)
59538
        HYBRID_BREAK();
59539
      HYBRID_CASE(ZEND_DIV_SPEC_CONST_CONST):
59540
        VM_TRACE(ZEND_DIV_SPEC_CONST_CONST)
59541
        ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59542
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CONST)
59543
        HYBRID_BREAK();
59544
      HYBRID_CASE(ZEND_MOD_SPEC_CONST_CONST):
59545
        VM_TRACE(ZEND_MOD_SPEC_CONST_CONST)
59546
        ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59547
        VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_CONST)
59548
        HYBRID_BREAK();
59549
      HYBRID_CASE(ZEND_SL_SPEC_CONST_CONST):
59550
        VM_TRACE(ZEND_SL_SPEC_CONST_CONST)
59551
        ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59552
        VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_CONST)
59553
        HYBRID_BREAK();
59554
      HYBRID_CASE(ZEND_SR_SPEC_CONST_CONST):
59555
        VM_TRACE(ZEND_SR_SPEC_CONST_CONST)
59556
        ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59557
        VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_CONST)
59558
        HYBRID_BREAK();
59559
      HYBRID_CASE(ZEND_POW_SPEC_CONST_CONST):
59560
        VM_TRACE(ZEND_POW_SPEC_CONST_CONST)
59561
        ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59562
        VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CONST)
59563
        HYBRID_BREAK();
59564
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST):
59565
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
59566
        ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59567
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
59568
        HYBRID_BREAK();
59569
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST):
59570
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
59571
        ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59572
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
59573
        HYBRID_BREAK();
59574
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CONST_CONST):
59575
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CONST_CONST)
59576
        ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59577
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CONST_CONST)
59578
        HYBRID_BREAK();
59579
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST):
59580
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
59581
        ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59582
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
59583
        HYBRID_BREAK();
59584
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_CONST):
59585
        VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_CONST)
59586
        ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59587
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_CONST)
59588
        HYBRID_BREAK();
59589
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST):
59590
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
59591
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59592
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
59593
        HYBRID_BREAK();
59594
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CONST):
59595
        VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CONST)
59596
        ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59597
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CONST)
59598
        HYBRID_BREAK();
59599
      HYBRID_CASE(ZEND_BW_OR_SPEC_CONST_CONST):
59600
        VM_TRACE(ZEND_BW_OR_SPEC_CONST_CONST)
59601
        ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59602
        VM_TRACE_OP_END(ZEND_BW_OR_SPEC_CONST_CONST)
59603
        HYBRID_BREAK();
59604
      HYBRID_CASE(ZEND_BW_AND_SPEC_CONST_CONST):
59605
        VM_TRACE(ZEND_BW_AND_SPEC_CONST_CONST)
59606
        ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59607
        VM_TRACE_OP_END(ZEND_BW_AND_SPEC_CONST_CONST)
59608
        HYBRID_BREAK();
59609
      HYBRID_CASE(ZEND_BW_XOR_SPEC_CONST_CONST):
59610
        VM_TRACE(ZEND_BW_XOR_SPEC_CONST_CONST)
59611
        ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59612
        VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_CONST_CONST)
59613
        HYBRID_BREAK();
59614
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CONST_CONST):
59615
        VM_TRACE(ZEND_BOOL_XOR_SPEC_CONST_CONST)
59616
        ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59617
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CONST_CONST)
59618
        HYBRID_BREAK();
59619
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST):
59620
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
59621
        ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59622
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
59623
        HYBRID_BREAK();
59624
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST):
59625
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
59626
        ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59627
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
59628
        HYBRID_BREAK();
59629
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST):
59630
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
59631
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59632
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
59633
        HYBRID_BREAK();
59634
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST):
59635
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
59636
        ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59637
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
59638
        HYBRID_BREAK();
59639
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST):
59640
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
59641
        ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59642
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
59643
        HYBRID_BREAK();
59644
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST):
59645
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
59646
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59647
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
59648
        HYBRID_BREAK();
59649
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST):
59650
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
59651
        ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59652
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
59653
        HYBRID_BREAK();
59654
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CONST):
59655
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
59656
        ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59657
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
59658
        HYBRID_BREAK();
59659
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST):
59660
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
59661
        ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59662
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
59663
        HYBRID_BREAK();
59664
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST):
59665
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
59666
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59667
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
59668
        HYBRID_BREAK();
59669
      HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST):
59670
        VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
59671
        ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59672
        VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
59673
        HYBRID_BREAK();
59674
      HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST):
59675
        VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST)
59676
        ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59677
        VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_CONST)
59678
        HYBRID_BREAK();
59679
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST):
59680
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
59681
        ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59682
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
59683
        HYBRID_BREAK();
59684
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST):
59685
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
59686
        ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59687
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
59688
        HYBRID_BREAK();
59689
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST):
59690
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
59691
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59692
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
59693
        HYBRID_BREAK();
59694
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CONST):
59695
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
59696
        ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59697
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
59698
        HYBRID_BREAK();
59699
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST):
59700
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
59701
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59702
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
59703
        HYBRID_BREAK();
59704
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST):
59705
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
59706
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59707
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
59708
        HYBRID_BREAK();
59709
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST):
59710
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
59711
        ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59712
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
59713
        HYBRID_BREAK();
59714
      HYBRID_CASE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST):
59715
        VM_TRACE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
59716
        ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59717
        VM_TRACE_OP_END(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
59718
        HYBRID_BREAK();
59719
      HYBRID_CASE(ZEND_DECLARE_CONST_SPEC_CONST_CONST):
59720
        VM_TRACE(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
59721
        ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59722
        VM_TRACE_OP_END(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
59723
        HYBRID_BREAK();
59724
      HYBRID_CASE(ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST):
59725
        VM_TRACE(ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST)
59726
        ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59727
        VM_TRACE_OP_END(ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST)
59728
        HYBRID_BREAK();
59729
      HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CONST):
59730
        VM_TRACE(ZEND_YIELD_SPEC_CONST_CONST)
59731
        ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59732
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CONST)
59733
        HYBRID_BREAK();
59734
      HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_CONST_CONST):
59735
        VM_TRACE(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
59736
        ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59737
        VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
59738
        HYBRID_BREAK();
59739
      HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_CONST_CONST):
59740
        VM_TRACE(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
59741
        ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59742
        VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
59743
        HYBRID_BREAK();
59744
      HYBRID_CASE(ZEND_MATCH_SPEC_CONST_CONST):
59745
        VM_TRACE(ZEND_MATCH_SPEC_CONST_CONST)
59746
        ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59747
        VM_TRACE_OP_END(ZEND_MATCH_SPEC_CONST_CONST)
59748
        HYBRID_BREAK();
59749
      HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CONST_CONST):
59750
        VM_TRACE(ZEND_IN_ARRAY_SPEC_CONST_CONST)
59751
        ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59752
        VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CONST_CONST)
59753
        HYBRID_BREAK();
59754
      HYBRID_CASE(ZEND_ADD_SPEC_CONST_TMPVARCV):
59755
        VM_TRACE(ZEND_ADD_SPEC_CONST_TMPVARCV)
59756
        ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59757
        VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_TMPVARCV)
59758
        HYBRID_BREAK();
59759
      HYBRID_CASE(ZEND_SUB_SPEC_CONST_TMPVARCV):
59760
        VM_TRACE(ZEND_SUB_SPEC_CONST_TMPVARCV)
59761
        ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59762
        VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_TMPVARCV)
59763
        HYBRID_BREAK();
59764
      HYBRID_CASE(ZEND_MOD_SPEC_CONST_TMPVARCV):
59765
        VM_TRACE(ZEND_MOD_SPEC_CONST_TMPVARCV)
59766
        ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59767
        VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_TMPVARCV)
59768
        HYBRID_BREAK();
59769
      HYBRID_CASE(ZEND_SL_SPEC_CONST_TMPVARCV):
59770
        VM_TRACE(ZEND_SL_SPEC_CONST_TMPVARCV)
59771
        ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59772
        VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_TMPVARCV)
59773
        HYBRID_BREAK();
59774
      HYBRID_CASE(ZEND_SR_SPEC_CONST_TMPVARCV):
59775
        VM_TRACE(ZEND_SR_SPEC_CONST_TMPVARCV)
59776
        ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59777
        VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_TMPVARCV)
59778
        HYBRID_BREAK();
59779
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV):
59780
        VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
59781
        ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59782
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
59783
        HYBRID_BREAK();
59784
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ):
59785
        VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
59786
        ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59787
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
59788
        HYBRID_BREAK();
59789
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ):
59790
        VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
59791
        ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59792
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
59793
        HYBRID_BREAK();
59794
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV):
59795
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
59796
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59797
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
59798
        HYBRID_BREAK();
59799
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ):
59800
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
59801
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59802
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
59803
        HYBRID_BREAK();
59804
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ):
59805
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
59806
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59807
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
59808
        HYBRID_BREAK();
59809
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV):
59810
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
59811
        ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59812
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
59813
        HYBRID_BREAK();
59814
      HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV):
59815
        VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
59816
        ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59817
        VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
59818
        HYBRID_BREAK();
59819
      HYBRID_CASE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV):
59820
        VM_TRACE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
59821
        ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59822
        VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
59823
        HYBRID_BREAK();
59824
      HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV):
59825
        VM_TRACE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
59826
        ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59827
        VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
59828
        HYBRID_BREAK();
59829
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV):
59830
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
59831
        ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59832
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
59833
        HYBRID_BREAK();
59834
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ):
59835
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59836
        ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59837
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59838
        HYBRID_BREAK();
59839
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
59840
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59841
        ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59842
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59843
        HYBRID_BREAK();
59844
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV):
59845
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
59846
        ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59847
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
59848
        HYBRID_BREAK();
59849
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
59850
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59851
        ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59852
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59853
        HYBRID_BREAK();
59854
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
59855
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59856
        ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59857
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59858
        HYBRID_BREAK();
59859
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV):
59860
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
59861
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59862
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
59863
        HYBRID_BREAK();
59864
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ):
59865
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59866
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59867
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59868
        HYBRID_BREAK();
59869
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
59870
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59871
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59872
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59873
        HYBRID_BREAK();
59874
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV):
59875
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
59876
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59877
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
59878
        HYBRID_BREAK();
59879
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
59880
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59881
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59882
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59883
        HYBRID_BREAK();
59884
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
59885
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59886
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59887
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59888
        HYBRID_BREAK();
59889
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV):
59890
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
59891
        ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59892
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
59893
        HYBRID_BREAK();
59894
      HYBRID_CASE(ZEND_DIV_SPEC_CONST_TMPVAR):
59895
        VM_TRACE(ZEND_DIV_SPEC_CONST_TMPVAR)
59896
        ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59897
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_TMPVAR)
59898
        HYBRID_BREAK();
59899
      HYBRID_CASE(ZEND_POW_SPEC_CONST_TMPVAR):
59900
        VM_TRACE(ZEND_POW_SPEC_CONST_TMPVAR)
59901
        ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59902
        VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_TMPVAR)
59903
        HYBRID_BREAK();
59904
      HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_TMPVAR):
59905
        VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMPVAR)
59906
        ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59907
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_TMPVAR)
59908
        HYBRID_BREAK();
59909
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR):
59910
        VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
59911
        ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59912
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
59913
        HYBRID_BREAK();
59914
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR):
59915
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
59916
        ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59917
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
59918
        HYBRID_BREAK();
59919
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR):
59920
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
59921
        ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59922
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
59923
        HYBRID_BREAK();
59924
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR):
59925
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
59926
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59927
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
59928
        HYBRID_BREAK();
59929
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR):
59930
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
59931
        ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59932
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
59933
        HYBRID_BREAK();
59934
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR):
59935
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
59936
        ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59937
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
59938
        HYBRID_BREAK();
59939
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR):
59940
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
59941
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59942
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
59943
        HYBRID_BREAK();
59944
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR):
59945
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
59946
        ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59947
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
59948
        HYBRID_BREAK();
59949
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR):
59950
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
59951
        ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59952
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
59953
        HYBRID_BREAK();
59954
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR):
59955
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
59956
        ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59957
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
59958
        HYBRID_BREAK();
59959
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR):
59960
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
59961
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59962
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
59963
        HYBRID_BREAK();
59964
      HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR):
59965
        VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
59966
        ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59967
        VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
59968
        HYBRID_BREAK();
59969
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR):
59970
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
59971
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59972
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
59973
        HYBRID_BREAK();
59974
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR):
59975
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
59976
        ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59977
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
59978
        HYBRID_BREAK();
59979
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR):
59980
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
59981
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59982
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
59983
        HYBRID_BREAK();
59984
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR):
59985
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
59986
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59987
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
59988
        HYBRID_BREAK();
59989
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR):
59990
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
59991
        ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59992
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
59993
        HYBRID_BREAK();
59994
      HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMPVAR):
59995
        VM_TRACE(ZEND_YIELD_SPEC_CONST_TMPVAR)
59996
        ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59997
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMPVAR)
59998
        HYBRID_BREAK();
59999
      HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED):
60000
        VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED)
60001
        ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60002
        VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CONST_UNUSED)
60003
        HYBRID_BREAK();
60004
      HYBRID_CASE(ZEND_FETCH_W_SPEC_CONST_UNUSED):
60005
        VM_TRACE(ZEND_FETCH_W_SPEC_CONST_UNUSED)
60006
        ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60007
        VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CONST_UNUSED)
60008
        HYBRID_BREAK();
60009
      HYBRID_CASE(ZEND_FETCH_RW_SPEC_CONST_UNUSED):
60010
        VM_TRACE(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
60011
        ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60012
        VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
60013
        HYBRID_BREAK();
60014
      HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED):
60015
        VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
60016
        ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60017
        VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
60018
        HYBRID_BREAK();
60019
      HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED):
60020
        VM_TRACE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
60021
        ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60022
        VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
60023
        HYBRID_BREAK();
60024
      HYBRID_CASE(ZEND_FETCH_IS_SPEC_CONST_UNUSED):
60025
        VM_TRACE(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
60026
        ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60027
        VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
60028
        HYBRID_BREAK();
60029
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED):
60030
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
60031
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60032
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
60033
        HYBRID_BREAK();
60034
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED):
60035
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
60036
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60037
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
60038
        HYBRID_BREAK();
60039
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED):
60040
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
60041
        ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60042
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
60043
        HYBRID_BREAK();
60044
      HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_UNUSED):
60045
        VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
60046
        ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60047
        VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
60048
        HYBRID_BREAK();
60049
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED):
60050
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
60051
        ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60052
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
60053
        HYBRID_BREAK();
60054
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK):
60055
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
60056
        ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60057
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
60058
        HYBRID_BREAK();
60059
      HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED):
60060
        VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED)
60061
        ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60062
        VM_TRACE_OP_END(ZEND_NEW_SPEC_CONST_UNUSED)
60063
        HYBRID_BREAK();
60064
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED):
60065
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
60066
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60067
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
60068
        HYBRID_BREAK();
60069
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED):
60070
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
60071
        ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60072
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
60073
        HYBRID_BREAK();
60074
      HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED):
60075
        VM_TRACE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
60076
        ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60077
        VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
60078
        HYBRID_BREAK();
60079
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED):
60080
        VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
60081
        ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60082
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
60083
        HYBRID_BREAK();
60084
      HYBRID_CASE(ZEND_YIELD_SPEC_CONST_UNUSED):
60085
        VM_TRACE(ZEND_YIELD_SPEC_CONST_UNUSED)
60086
        ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60087
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_UNUSED)
60088
        HYBRID_BREAK();
60089
      HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED):
60090
        VM_TRACE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
60091
        ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60092
        VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
60093
        HYBRID_BREAK();
60094
      HYBRID_CASE(ZEND_COUNT_SPEC_CONST_UNUSED):
60095
        VM_TRACE(ZEND_COUNT_SPEC_CONST_UNUSED)
60096
        ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60097
        VM_TRACE_OP_END(ZEND_COUNT_SPEC_CONST_UNUSED)
60098
        HYBRID_BREAK();
60099
      HYBRID_CASE(ZEND_GET_CLASS_SPEC_CONST_UNUSED):
60100
        VM_TRACE(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
60101
        ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60102
        VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
60103
        HYBRID_BREAK();
60104
      HYBRID_CASE(ZEND_GET_TYPE_SPEC_CONST_UNUSED):
60105
        VM_TRACE(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
60106
        ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60107
        VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
60108
        HYBRID_BREAK();
60109
      HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED):
60110
        VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
60111
        ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60112
        VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
60113
        HYBRID_BREAK();
60114
      HYBRID_CASE(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED):
60115
        VM_TRACE(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
60116
        ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60117
        VM_TRACE_OP_END(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
60118
        HYBRID_BREAK();
60119
      HYBRID_CASE(ZEND_DIV_SPEC_CONST_CV):
60120
        VM_TRACE(ZEND_DIV_SPEC_CONST_CV)
60121
        ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60122
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CV)
60123
        HYBRID_BREAK();
60124
      HYBRID_CASE(ZEND_POW_SPEC_CONST_CV):
60125
        VM_TRACE(ZEND_POW_SPEC_CONST_CV)
60126
        ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60127
        VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CV)
60128
        HYBRID_BREAK();
60129
      HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_CV):
60130
        VM_TRACE(ZEND_CONCAT_SPEC_CONST_CV)
60131
        ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60132
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_CV)
60133
        HYBRID_BREAK();
60134
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CV):
60135
        VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CV)
60136
        ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60137
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CV)
60138
        HYBRID_BREAK();
60139
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CV):
60140
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
60141
        ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60142
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
60143
        HYBRID_BREAK();
60144
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV):
60145
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
60146
        ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60147
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
60148
        HYBRID_BREAK();
60149
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV):
60150
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
60151
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60152
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
60153
        HYBRID_BREAK();
60154
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV):
60155
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
60156
        ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60157
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
60158
        HYBRID_BREAK();
60159
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV):
60160
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
60161
        ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60162
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
60163
        HYBRID_BREAK();
60164
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV):
60165
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
60166
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60167
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
60168
        HYBRID_BREAK();
60169
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CV):
60170
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
60171
        ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60172
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
60173
        HYBRID_BREAK();
60174
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CV):
60175
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CV)
60176
        ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60177
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CV)
60178
        HYBRID_BREAK();
60179
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV):
60180
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
60181
        ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60182
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
60183
        HYBRID_BREAK();
60184
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV):
60185
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
60186
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60187
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
60188
        HYBRID_BREAK();
60189
      HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV):
60190
        VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
60191
        ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60192
        VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
60193
        HYBRID_BREAK();
60194
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV):
60195
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
60196
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60197
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
60198
        HYBRID_BREAK();
60199
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CV):
60200
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CV)
60201
        ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60202
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CV)
60203
        HYBRID_BREAK();
60204
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV):
60205
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
60206
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60207
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
60208
        HYBRID_BREAK();
60209
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV):
60210
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
60211
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60212
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
60213
        HYBRID_BREAK();
60214
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV):
60215
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
60216
        ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60217
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
60218
        HYBRID_BREAK();
60219
      HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CV):
60220
        VM_TRACE(ZEND_YIELD_SPEC_CONST_CV)
60221
        ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60222
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CV)
60223
        HYBRID_BREAK();
60224
      HYBRID_CASE(ZEND_BW_NOT_SPEC_TMPVARCV):
60225
        VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV)
60226
        ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60227
        VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_TMPVARCV)
60228
        HYBRID_BREAK();
60229
      HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV):
60230
        VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
60231
        ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60232
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
60233
        HYBRID_BREAK();
60234
      HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV):
60235
        VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
60236
        ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60237
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
60238
        HYBRID_BREAK();
60239
      HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV):
60240
        VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
60241
        ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60242
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
60243
        HYBRID_BREAK();
60244
      HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_CONST):
60245
        VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_CONST)
60246
        ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60247
        VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_CONST)
60248
        HYBRID_BREAK();
60249
      HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_CONST):
60250
        VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_CONST)
60251
        ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60252
        VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_CONST)
60253
        HYBRID_BREAK();
60254
      HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_CONST):
60255
        VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_CONST)
60256
        ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60257
        VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_CONST)
60258
        HYBRID_BREAK();
60259
      HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_CONST):
60260
        VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_CONST)
60261
        ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60262
        VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_CONST)
60263
        HYBRID_BREAK();
60264
      HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_CONST):
60265
        VM_TRACE(ZEND_SL_SPEC_TMPVARCV_CONST)
60266
        ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60267
        VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_CONST)
60268
        HYBRID_BREAK();
60269
      HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_CONST):
60270
        VM_TRACE(ZEND_SR_SPEC_TMPVARCV_CONST)
60271
        ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60272
        VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_CONST)
60273
        HYBRID_BREAK();
60274
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST):
60275
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
60276
        ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60277
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
60278
        HYBRID_BREAK();
60279
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ):
60280
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
60281
        ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60282
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
60283
        HYBRID_BREAK();
60284
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ):
60285
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
60286
        ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60287
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
60288
        HYBRID_BREAK();
60289
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST):
60290
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
60291
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60292
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
60293
        HYBRID_BREAK();
60294
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ):
60295
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
60296
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60297
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
60298
        HYBRID_BREAK();
60299
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ):
60300
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
60301
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60302
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
60303
        HYBRID_BREAK();
60304
      HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_CONST):
60305
        VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
60306
        ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60307
        VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
60308
        HYBRID_BREAK();
60309
      HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_CONST):
60310
        VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
60311
        ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60312
        VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
60313
        HYBRID_BREAK();
60314
      HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST):
60315
        VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
60316
        ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60317
        VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
60318
        HYBRID_BREAK();
60319
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST):
60320
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
60321
        ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60322
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
60323
        HYBRID_BREAK();
60324
      HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST):
60325
        VM_TRACE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
60326
        ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60327
        VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
60328
        HYBRID_BREAK();
60329
      HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST):
60330
        VM_TRACE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
60331
        ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60332
        VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
60333
        HYBRID_BREAK();
60334
      HYBRID_CASE(ZEND_MATCH_SPEC_TMPVARCV_CONST):
60335
        VM_TRACE(ZEND_MATCH_SPEC_TMPVARCV_CONST)
60336
        ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60337
        VM_TRACE_OP_END(ZEND_MATCH_SPEC_TMPVARCV_CONST)
60338
        HYBRID_BREAK();
60339
      HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60340
        VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60341
        ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60342
        VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60343
        HYBRID_BREAK();
60344
      HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST):
60345
        VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
60346
        ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60347
        VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
60348
        HYBRID_BREAK();
60349
      HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST):
60350
        VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
60351
        ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60352
        VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
60353
        HYBRID_BREAK();
60354
      HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60355
        VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60356
        ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60357
        VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60358
        HYBRID_BREAK();
60359
      HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST):
60360
        VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
60361
        ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60362
        VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
60363
        HYBRID_BREAK();
60364
      HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST):
60365
        VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
60366
        ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60367
        VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
60368
        HYBRID_BREAK();
60369
      HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60370
        VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60371
        ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60372
        VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60373
        HYBRID_BREAK();
60374
      HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST):
60375
        VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
60376
        ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60377
        VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
60378
        HYBRID_BREAK();
60379
      HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST):
60380
        VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
60381
        ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60382
        VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
60383
        HYBRID_BREAK();
60384
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60385
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60386
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60387
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60388
        HYBRID_BREAK();
60389
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60390
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60391
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60392
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60393
        HYBRID_BREAK();
60394
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60395
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60396
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60397
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60398
        HYBRID_BREAK();
60399
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60400
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60401
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60402
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60403
        HYBRID_BREAK();
60404
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60405
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60406
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60407
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60408
        HYBRID_BREAK();
60409
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60410
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60411
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60412
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60413
        HYBRID_BREAK();
60414
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60415
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60416
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60417
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60418
        HYBRID_BREAK();
60419
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60420
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60421
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60422
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60423
        HYBRID_BREAK();
60424
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60425
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60426
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60427
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60428
        HYBRID_BREAK();
60429
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60430
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60431
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60432
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60433
        HYBRID_BREAK();
60434
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60435
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60436
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60437
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60438
        HYBRID_BREAK();
60439
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60440
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60441
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60442
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60443
        HYBRID_BREAK();
60444
      HYBRID_CASE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST):
60445
        VM_TRACE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST)
60446
        ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60447
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST)
60448
        HYBRID_BREAK();
60449
      HYBRID_CASE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ):
60450
        VM_TRACE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ)
60451
        ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60452
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ)
60453
        HYBRID_BREAK();
60454
      HYBRID_CASE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ):
60455
        VM_TRACE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ)
60456
        ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60457
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ)
60458
        HYBRID_BREAK();
60459
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST):
60460
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST)
60461
        ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60462
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST)
60463
        HYBRID_BREAK();
60464
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ):
60465
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ)
60466
        ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60467
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ)
60468
        HYBRID_BREAK();
60469
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ):
60470
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ)
60471
        ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60472
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ)
60473
        HYBRID_BREAK();
60474
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST):
60475
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
60476
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60477
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
60478
        HYBRID_BREAK();
60479
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60480
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60481
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60482
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60483
        HYBRID_BREAK();
60484
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60485
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60486
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60487
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60488
        HYBRID_BREAK();
60489
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST):
60490
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
60491
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60492
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
60493
        HYBRID_BREAK();
60494
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60495
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60496
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60497
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60498
        HYBRID_BREAK();
60499
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60500
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60501
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60502
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60503
        HYBRID_BREAK();
60504
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60505
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60506
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60507
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60508
        HYBRID_BREAK();
60509
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60510
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60511
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60512
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60513
        HYBRID_BREAK();
60514
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60515
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60516
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60517
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60518
        HYBRID_BREAK();
60519
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60520
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60521
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60522
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60523
        HYBRID_BREAK();
60524
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60525
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60526
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60527
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60528
        HYBRID_BREAK();
60529
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60530
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60531
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60532
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60533
        HYBRID_BREAK();
60534
      HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV):
60535
        VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
60536
        ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60537
        VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
60538
        HYBRID_BREAK();
60539
      HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV):
60540
        VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
60541
        ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60542
        VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
60543
        HYBRID_BREAK();
60544
      HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV):
60545
        VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
60546
        ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60547
        VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
60548
        HYBRID_BREAK();
60549
      HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV):
60550
        VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
60551
        ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60552
        VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
60553
        HYBRID_BREAK();
60554
      HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV):
60555
        VM_TRACE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
60556
        ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60557
        VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
60558
        HYBRID_BREAK();
60559
      HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV):
60560
        VM_TRACE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
60561
        ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60562
        VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
60563
        HYBRID_BREAK();
60564
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV):
60565
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
60566
        ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60567
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
60568
        HYBRID_BREAK();
60569
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60570
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60571
        ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60572
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60573
        HYBRID_BREAK();
60574
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60575
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60576
        ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60577
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60578
        HYBRID_BREAK();
60579
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV):
60580
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
60581
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60582
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
60583
        HYBRID_BREAK();
60584
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60585
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60586
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60587
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60588
        HYBRID_BREAK();
60589
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60590
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60591
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60592
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60593
        HYBRID_BREAK();
60594
      HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV):
60595
        VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
60596
        ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60597
        VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
60598
        HYBRID_BREAK();
60599
      HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV):
60600
        VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
60601
        ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60602
        VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
60603
        HYBRID_BREAK();
60604
      HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV):
60605
        VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
60606
        ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60607
        VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
60608
        HYBRID_BREAK();
60609
      HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60610
        VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60611
        ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60612
        VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60613
        HYBRID_BREAK();
60614
      HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV):
60615
        VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
60616
        ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60617
        VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
60618
        HYBRID_BREAK();
60619
      HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60620
        VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60621
        ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60622
        VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60623
        HYBRID_BREAK();
60624
      HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60625
        VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60626
        ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60627
        VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60628
        HYBRID_BREAK();
60629
      HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV):
60630
        VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
60631
        ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60632
        VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
60633
        HYBRID_BREAK();
60634
      HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60635
        VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60636
        ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60637
        VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60638
        HYBRID_BREAK();
60639
      HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60640
        VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60641
        ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60642
        VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60643
        HYBRID_BREAK();
60644
      HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV):
60645
        VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
60646
        ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60647
        VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
60648
        HYBRID_BREAK();
60649
      HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60650
        VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60651
        ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60652
        VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60653
        HYBRID_BREAK();
60654
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60655
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60656
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60657
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60658
        HYBRID_BREAK();
60659
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60660
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60661
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60662
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60663
        HYBRID_BREAK();
60664
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60665
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60666
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60667
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60668
        HYBRID_BREAK();
60669
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60670
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60671
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60672
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60673
        HYBRID_BREAK();
60674
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60675
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60676
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60677
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60678
        HYBRID_BREAK();
60679
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60680
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60681
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60682
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60683
        HYBRID_BREAK();
60684
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60685
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60686
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60687
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60688
        HYBRID_BREAK();
60689
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60690
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60691
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60692
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60693
        HYBRID_BREAK();
60694
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60695
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60696
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60697
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60698
        HYBRID_BREAK();
60699
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60700
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60701
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60702
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60703
        HYBRID_BREAK();
60704
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60705
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60706
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60707
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60708
        HYBRID_BREAK();
60709
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60710
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60711
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60712
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60713
        HYBRID_BREAK();
60714
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV):
60715
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
60716
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60717
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
60718
        HYBRID_BREAK();
60719
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60720
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60721
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60722
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60723
        HYBRID_BREAK();
60724
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60725
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60726
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60727
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60728
        HYBRID_BREAK();
60729
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60730
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60731
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60732
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60733
        HYBRID_BREAK();
60734
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60735
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60736
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60737
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60738
        HYBRID_BREAK();
60739
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60740
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60741
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60742
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60743
        HYBRID_BREAK();
60744
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60745
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60746
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60747
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60748
        HYBRID_BREAK();
60749
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60750
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60751
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60752
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60753
        HYBRID_BREAK();
60754
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60755
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60756
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60757
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60758
        HYBRID_BREAK();
60759
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60760
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60761
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60762
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60763
        HYBRID_BREAK();
60764
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60765
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60766
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60767
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60768
        HYBRID_BREAK();
60769
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60770
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60771
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60772
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60773
        HYBRID_BREAK();
60774
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR):
60775
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
60776
        ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60777
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
60778
        HYBRID_BREAK();
60779
      HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED):
60780
        VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
60781
        ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60782
        VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
60783
        HYBRID_BREAK();
60784
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV):
60785
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
60786
        ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60787
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
60788
        HYBRID_BREAK();
60789
      HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR):
60790
        VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR)
60791
        ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60792
        VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR)
60793
        HYBRID_BREAK();
60794
      HYBRID_CASE(ZEND_ECHO_SPEC_TMPVAR):
60795
        VM_TRACE(ZEND_ECHO_SPEC_TMPVAR)
60796
        ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60797
        VM_TRACE_OP_END(ZEND_ECHO_SPEC_TMPVAR)
60798
        HYBRID_BREAK();
60799
      HYBRID_CASE(ZEND_JMPZ_SPEC_TMPVAR):
60800
        VM_TRACE(ZEND_JMPZ_SPEC_TMPVAR)
60801
        ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60802
        VM_TRACE_OP_END(ZEND_JMPZ_SPEC_TMPVAR)
60803
        HYBRID_BREAK();
60804
      HYBRID_CASE(ZEND_JMPNZ_SPEC_TMPVAR):
60805
        VM_TRACE(ZEND_JMPNZ_SPEC_TMPVAR)
60806
        ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60807
        VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_TMPVAR)
60808
        HYBRID_BREAK();
60809
      HYBRID_CASE(ZEND_JMPZ_EX_SPEC_TMPVAR):
60810
        VM_TRACE(ZEND_JMPZ_EX_SPEC_TMPVAR)
60811
        ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60812
        VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_TMPVAR)
60813
        HYBRID_BREAK();
60814
      HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_TMPVAR):
60815
        VM_TRACE(ZEND_JMPNZ_EX_SPEC_TMPVAR)
60816
        ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60817
        VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_TMPVAR)
60818
        HYBRID_BREAK();
60819
      HYBRID_CASE(ZEND_FREE_SPEC_TMPVAR):
60820
        VM_TRACE(ZEND_FREE_SPEC_TMPVAR)
60821
        ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60822
        VM_TRACE_OP_END(ZEND_FREE_SPEC_TMPVAR)
60823
        HYBRID_BREAK();
60824
      HYBRID_CASE(ZEND_FE_FREE_SPEC_TMPVAR):
60825
        VM_TRACE(ZEND_FE_FREE_SPEC_TMPVAR)
60826
        ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60827
        VM_TRACE_OP_END(ZEND_FE_FREE_SPEC_TMPVAR)
60828
        HYBRID_BREAK();
60829
      HYBRID_CASE(ZEND_THROW_SPEC_TMPVAR):
60830
        VM_TRACE(ZEND_THROW_SPEC_TMPVAR)
60831
        ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60832
        VM_TRACE_OP_END(ZEND_THROW_SPEC_TMPVAR)
60833
        HYBRID_BREAK();
60834
      HYBRID_CASE(ZEND_BOOL_SPEC_TMPVAR):
60835
        VM_TRACE(ZEND_BOOL_SPEC_TMPVAR)
60836
        ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60837
        VM_TRACE_OP_END(ZEND_BOOL_SPEC_TMPVAR)
60838
        HYBRID_BREAK();
60839
      HYBRID_CASE(ZEND_CLONE_SPEC_TMPVAR):
60840
        VM_TRACE(ZEND_CLONE_SPEC_TMPVAR)
60841
        ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60842
        VM_TRACE_OP_END(ZEND_CLONE_SPEC_TMPVAR)
60843
        HYBRID_BREAK();
60844
      HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR):
60845
        VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
60846
        ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60847
        VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
60848
        HYBRID_BREAK();
60849
      HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR):
60850
        VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR)
60851
        ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60852
        VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_TMPVAR)
60853
        HYBRID_BREAK();
60854
      HYBRID_CASE(ZEND_STRLEN_SPEC_TMPVAR):
60855
        VM_TRACE(ZEND_STRLEN_SPEC_TMPVAR)
60856
        ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60857
        VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMPVAR)
60858
        HYBRID_BREAK();
60859
      HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR):
60860
        VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR)
60861
        ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60862
        VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR)
60863
        HYBRID_BREAK();
60864
      HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR):
60865
        VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
60866
        ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60867
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
60868
        HYBRID_BREAK();
60869
      HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CONST):
60870
        VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CONST)
60871
        ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60872
        VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CONST)
60873
        HYBRID_BREAK();
60874
      HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CONST):
60875
        VM_TRACE(ZEND_POW_SPEC_TMPVAR_CONST)
60876
        ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60877
        VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CONST)
60878
        HYBRID_BREAK();
60879
      HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CONST):
60880
        VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CONST)
60881
        ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60882
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CONST)
60883
        HYBRID_BREAK();
60884
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST):
60885
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
60886
        ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60887
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
60888
        HYBRID_BREAK();
60889
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
60890
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60891
        ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60892
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60893
        HYBRID_BREAK();
60894
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
60895
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60896
        ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60897
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60898
        HYBRID_BREAK();
60899
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST):
60900
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
60901
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60902
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
60903
        HYBRID_BREAK();
60904
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
60905
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60906
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60907
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60908
        HYBRID_BREAK();
60909
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
60910
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60911
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60912
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60913
        HYBRID_BREAK();
60914
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST):
60915
        VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
60916
        ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60917
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
60918
        HYBRID_BREAK();
60919
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST):
60920
        VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
60921
        ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60922
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
60923
        HYBRID_BREAK();
60924
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST):
60925
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
60926
        ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60927
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
60928
        HYBRID_BREAK();
60929
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST):
60930
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
60931
        ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60932
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
60933
        HYBRID_BREAK();
60934
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST):
60935
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
60936
        ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60937
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
60938
        HYBRID_BREAK();
60939
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST):
60940
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
60941
        ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60942
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
60943
        HYBRID_BREAK();
60944
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST):
60945
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
60946
        ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60947
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
60948
        HYBRID_BREAK();
60949
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST):
60950
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
60951
        ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60952
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
60953
        HYBRID_BREAK();
60954
      HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST):
60955
        VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
60956
        ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60957
        VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
60958
        HYBRID_BREAK();
60959
      HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CONST):
60960
        VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CONST)
60961
        ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60962
        VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CONST)
60963
        HYBRID_BREAK();
60964
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST):
60965
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
60966
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60967
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
60968
        HYBRID_BREAK();
60969
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST):
60970
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
60971
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60972
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
60973
        HYBRID_BREAK();
60974
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST):
60975
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
60976
        ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60977
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
60978
        HYBRID_BREAK();
60979
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST):
60980
        VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
60981
        ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60982
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
60983
        HYBRID_BREAK();
60984
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST):
60985
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
60986
        ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60987
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
60988
        HYBRID_BREAK();
60989
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV):
60990
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
60991
        ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60992
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
60993
        HYBRID_BREAK();
60994
      HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_TMPVAR):
60995
        VM_TRACE(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
60996
        ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60997
        VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
60998
        HYBRID_BREAK();
60999
      HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_TMPVAR):
61000
        VM_TRACE(ZEND_POW_SPEC_TMPVAR_TMPVAR)
61001
        ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61002
        VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_TMPVAR)
61003
        HYBRID_BREAK();
61004
      HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR):
61005
        VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
61006
        ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61007
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
61008
        HYBRID_BREAK();
61009
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR):
61010
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
61011
        ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61012
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
61013
        HYBRID_BREAK();
61014
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
61015
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
61016
        ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61017
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
61018
        HYBRID_BREAK();
61019
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
61020
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
61021
        ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61022
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
61023
        HYBRID_BREAK();
61024
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR):
61025
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
61026
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61027
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
61028
        HYBRID_BREAK();
61029
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
61030
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
61031
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61032
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
61033
        HYBRID_BREAK();
61034
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
61035
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
61036
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61037
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
61038
        HYBRID_BREAK();
61039
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR):
61040
        VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
61041
        ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61042
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
61043
        HYBRID_BREAK();
61044
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR):
61045
        VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
61046
        ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61047
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
61048
        HYBRID_BREAK();
61049
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR):
61050
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
61051
        ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61052
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
61053
        HYBRID_BREAK();
61054
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR):
61055
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
61056
        ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61057
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
61058
        HYBRID_BREAK();
61059
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR):
61060
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
61061
        ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61062
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
61063
        HYBRID_BREAK();
61064
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR):
61065
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
61066
        ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61067
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
61068
        HYBRID_BREAK();
61069
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR):
61070
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
61071
        ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61072
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
61073
        HYBRID_BREAK();
61074
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR):
61075
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
61076
        ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61077
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
61078
        HYBRID_BREAK();
61079
      HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR):
61080
        VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
61081
        ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61082
        VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
61083
        HYBRID_BREAK();
61084
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR):
61085
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
61086
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61087
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
61088
        HYBRID_BREAK();
61089
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR):
61090
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
61091
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61092
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
61093
        HYBRID_BREAK();
61094
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR):
61095
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
61096
        ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61097
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
61098
        HYBRID_BREAK();
61099
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR):
61100
        VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
61101
        ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61102
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
61103
        HYBRID_BREAK();
61104
      HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED):
61105
        VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
61106
        ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61107
        VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
61108
        HYBRID_BREAK();
61109
      HYBRID_CASE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED):
61110
        VM_TRACE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
61111
        ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61112
        VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
61113
        HYBRID_BREAK();
61114
      HYBRID_CASE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED):
61115
        VM_TRACE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
61116
        ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61117
        VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
61118
        HYBRID_BREAK();
61119
      HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED):
61120
        VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
61121
        ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61122
        VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
61123
        HYBRID_BREAK();
61124
      HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED):
61125
        VM_TRACE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
61126
        ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61127
        VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
61128
        HYBRID_BREAK();
61129
      HYBRID_CASE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED):
61130
        VM_TRACE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
61131
        ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61132
        VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
61133
        HYBRID_BREAK();
61134
      HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED):
61135
        VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
61136
        ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61137
        VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
61138
        HYBRID_BREAK();
61139
      HYBRID_CASE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED):
61140
        VM_TRACE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
61141
        ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61142
        VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
61143
        HYBRID_BREAK();
61144
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED):
61145
        VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
61146
        ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61147
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
61148
        HYBRID_BREAK();
61149
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED):
61150
        VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
61151
        ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61152
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
61153
        HYBRID_BREAK();
61154
      HYBRID_CASE(ZEND_COUNT_SPEC_TMPVAR_UNUSED):
61155
        VM_TRACE(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
61156
        ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61157
        VM_TRACE_OP_END(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
61158
        HYBRID_BREAK();
61159
      HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED):
61160
        VM_TRACE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
61161
        ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61162
        VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
61163
        HYBRID_BREAK();
61164
      HYBRID_CASE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED):
61165
        VM_TRACE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
61166
        ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61167
        VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
61168
        HYBRID_BREAK();
61169
      HYBRID_CASE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED):
61170
        VM_TRACE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
61171
        ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61172
        VM_TRACE_OP_END(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
61173
        HYBRID_BREAK();
61174
      HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CV):
61175
        VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CV)
61176
        ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61177
        VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CV)
61178
        HYBRID_BREAK();
61179
      HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CV):
61180
        VM_TRACE(ZEND_POW_SPEC_TMPVAR_CV)
61181
        ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61182
        VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CV)
61183
        HYBRID_BREAK();
61184
      HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CV):
61185
        VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CV)
61186
        ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61187
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CV)
61188
        HYBRID_BREAK();
61189
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CV):
61190
        VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
61191
        ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61192
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
61193
        HYBRID_BREAK();
61194
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV):
61195
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
61196
        ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61197
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
61198
        HYBRID_BREAK();
61199
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV):
61200
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
61201
        ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61202
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
61203
        HYBRID_BREAK();
61204
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV):
61205
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
61206
        ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61207
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
61208
        HYBRID_BREAK();
61209
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV):
61210
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
61211
        ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61212
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
61213
        HYBRID_BREAK();
61214
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV):
61215
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
61216
        ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61217
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
61218
        HYBRID_BREAK();
61219
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV):
61220
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
61221
        ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61222
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
61223
        HYBRID_BREAK();
61224
      HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV):
61225
        VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV)
61226
        ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61227
        VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CV)
61228
        HYBRID_BREAK();
61229
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV):
61230
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
61231
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61232
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
61233
        HYBRID_BREAK();
61234
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV):
61235
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
61236
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61237
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
61238
        HYBRID_BREAK();
61239
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV):
61240
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
61241
        ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61242
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
61243
        HYBRID_BREAK();
61244
      HYBRID_CASE(ZEND_RETURN_SPEC_TMP):
61245
        VM_TRACE(ZEND_RETURN_SPEC_TMP)
61246
{
61247
  USE_OPLINE
61248
  zval *retval_ptr;
61249
  zval *return_value;
61250
61251
  retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
61252
  return_value = EX(return_value);
61253
61254
  if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61255
    SAVE_OPLINE();
61256
    retval_ptr = ZVAL_UNDEFINED_OP1();
61257
    if (return_value) {
61258
      ZVAL_NULL(return_value);
61259
    }
61260
  } else if (!return_value) {
61261
    if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
61262
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61263
        SAVE_OPLINE();
61264
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
61265
      }
61266
    }
61267
  } else {
61268
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
61269
      ZVAL_COPY_VALUE(return_value, retval_ptr);
61270
      if (IS_TMP_VAR == IS_CONST) {
61271
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61272
          Z_ADDREF_P(return_value);
61273
        }
61274
      }
61275
    } else if (IS_TMP_VAR == IS_CV) {
61276
      do {
61277
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61278
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61279
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61280
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61281
              ZVAL_COPY_VALUE(return_value, retval_ptr);
61282
              if (GC_MAY_LEAK(ref)) {
61283
                SAVE_OPLINE();
61284
                gc_possible_root(ref);
61285
              }
61286
              ZVAL_NULL(retval_ptr);
61287
              break;
61288
            } else {
61289
              Z_ADDREF_P(retval_ptr);
61290
            }
61291
          } else {
61292
            retval_ptr = Z_REFVAL_P(retval_ptr);
61293
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61294
              Z_ADDREF_P(retval_ptr);
61295
            }
61296
          }
61297
        }
61298
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61299
      } while (0);
61300
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
61301
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61302
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61303
61304
        retval_ptr = Z_REFVAL_P(retval_ptr);
61305
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61306
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61307
          efree_size(ref, sizeof(zend_reference));
61308
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61309
          Z_ADDREF_P(retval_ptr);
61310
        }
61311
      } else {
61312
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61313
      }
61314
    }
61315
  }
61316
61317
61318
61319
  goto zend_leave_helper_SPEC_LABEL;
61320
}
61321
61322
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_TMP)
61323
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_TMP):
61324
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP)
61325
        ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61326
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_TMP)
61327
        HYBRID_BREAK();
61328
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP):
61329
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP)
61330
        ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61331
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_TMP)
61332
        HYBRID_BREAK();
61333
      HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP):
61334
        VM_TRACE(ZEND_SEND_USER_SPEC_TMP)
61335
        ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61336
        VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP)
61337
        HYBRID_BREAK();
61338
      HYBRID_CASE(ZEND_CAST_SPEC_TMP):
61339
        VM_TRACE(ZEND_CAST_SPEC_TMP)
61340
        ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61341
        VM_TRACE_OP_END(ZEND_CAST_SPEC_TMP)
61342
        HYBRID_BREAK();
61343
      HYBRID_CASE(ZEND_FE_RESET_R_SPEC_TMP):
61344
        VM_TRACE(ZEND_FE_RESET_R_SPEC_TMP)
61345
        ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61346
        VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_TMP)
61347
        HYBRID_BREAK();
61348
      HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_TMP):
61349
        VM_TRACE(ZEND_FE_RESET_RW_SPEC_TMP)
61350
        ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61351
        VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_TMP)
61352
        HYBRID_BREAK();
61353
      HYBRID_CASE(ZEND_END_SILENCE_SPEC_TMP):
61354
        VM_TRACE(ZEND_END_SILENCE_SPEC_TMP)
61355
        ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61356
        VM_TRACE_OP_END(ZEND_END_SILENCE_SPEC_TMP)
61357
        HYBRID_BREAK();
61358
      HYBRID_CASE(ZEND_JMP_SET_SPEC_TMP):
61359
        VM_TRACE(ZEND_JMP_SET_SPEC_TMP)
61360
        ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61361
        VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_TMP)
61362
        HYBRID_BREAK();
61363
      HYBRID_CASE(ZEND_COALESCE_SPEC_TMP):
61364
        VM_TRACE(ZEND_COALESCE_SPEC_TMP)
61365
        ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61366
        VM_TRACE_OP_END(ZEND_COALESCE_SPEC_TMP)
61367
        HYBRID_BREAK();
61368
      HYBRID_CASE(ZEND_JMP_NULL_SPEC_TMP):
61369
        VM_TRACE(ZEND_JMP_NULL_SPEC_TMP)
61370
        ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61371
        VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_TMP)
61372
        HYBRID_BREAK();
61373
      HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_TMP):
61374
        VM_TRACE(ZEND_QM_ASSIGN_SPEC_TMP)
61375
        ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61376
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_TMP)
61377
        HYBRID_BREAK();
61378
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST):
61379
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
61380
        ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61381
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
61382
        HYBRID_BREAK();
61383
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CONST):
61384
        VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CONST)
61385
        ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61386
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CONST)
61387
        HYBRID_BREAK();
61388
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST):
61389
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
61390
        ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61391
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
61392
        HYBRID_BREAK();
61393
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST):
61394
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
61395
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61396
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
61397
        HYBRID_BREAK();
61398
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST):
61399
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
61400
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61401
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
61402
        HYBRID_BREAK();
61403
      HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CONST):
61404
        VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CONST)
61405
        ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61406
        VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CONST)
61407
        HYBRID_BREAK();
61408
      HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CONST):
61409
        VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CONST)
61410
        ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61411
        VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CONST)
61412
        HYBRID_BREAK();
61413
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST):
61414
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
61415
        ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61416
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
61417
        HYBRID_BREAK();
61418
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST):
61419
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
61420
        ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61421
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
61422
        HYBRID_BREAK();
61423
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CONST):
61424
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
61425
        ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61426
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
61427
        HYBRID_BREAK();
61428
      HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CONST):
61429
        VM_TRACE(ZEND_YIELD_SPEC_TMP_CONST)
61430
        ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61431
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CONST)
61432
        HYBRID_BREAK();
61433
      HYBRID_CASE(ZEND_IN_ARRAY_SPEC_TMP_CONST):
61434
        VM_TRACE(ZEND_IN_ARRAY_SPEC_TMP_CONST)
61435
        ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61436
        VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_TMP_CONST)
61437
        HYBRID_BREAK();
61438
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR):
61439
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
61440
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61441
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
61442
        HYBRID_BREAK();
61443
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR):
61444
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
61445
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61446
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
61447
        HYBRID_BREAK();
61448
      HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR):
61449
        VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
61450
        ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61451
        VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
61452
        HYBRID_BREAK();
61453
      HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_TMPVAR):
61454
        VM_TRACE(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
61455
        ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61456
        VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
61457
        HYBRID_BREAK();
61458
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR):
61459
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
61460
        ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61461
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
61462
        HYBRID_BREAK();
61463
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR):
61464
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
61465
        ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61466
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
61467
        HYBRID_BREAK();
61468
      HYBRID_CASE(ZEND_YIELD_SPEC_TMP_TMPVAR):
61469
        VM_TRACE(ZEND_YIELD_SPEC_TMP_TMPVAR)
61470
        ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61471
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_TMPVAR)
61472
        HYBRID_BREAK();
61473
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP):
61474
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
61475
        ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61476
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
61477
        HYBRID_BREAK();
61478
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_TMP):
61479
        VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_TMP)
61480
        ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61481
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_TMP)
61482
        HYBRID_BREAK();
61483
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP):
61484
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
61485
        ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61486
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
61487
        HYBRID_BREAK();
61488
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_VAR):
61489
        VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_VAR)
61490
        ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61491
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_VAR)
61492
        HYBRID_BREAK();
61493
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED):
61494
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
61495
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61496
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
61497
        HYBRID_BREAK();
61498
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED):
61499
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
61500
        ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61501
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
61502
        HYBRID_BREAK();
61503
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED):
61504
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
61505
        ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61506
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
61507
        HYBRID_BREAK();
61508
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK):
61509
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
61510
        ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61511
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
61512
        HYBRID_BREAK();
61513
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED):
61514
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
61515
        ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61516
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
61517
        HYBRID_BREAK();
61518
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED):
61519
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
61520
        ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61521
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
61522
        HYBRID_BREAK();
61523
      HYBRID_CASE(ZEND_YIELD_SPEC_TMP_UNUSED):
61524
        VM_TRACE(ZEND_YIELD_SPEC_TMP_UNUSED)
61525
        ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61526
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_UNUSED)
61527
        HYBRID_BREAK();
61528
      HYBRID_CASE(ZEND_GET_TYPE_SPEC_TMP_UNUSED):
61529
        VM_TRACE(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
61530
        ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61531
        VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
61532
        HYBRID_BREAK();
61533
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV):
61534
        VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV)
61535
        ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61536
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CV)
61537
        HYBRID_BREAK();
61538
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV):
61539
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
61540
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61541
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
61542
        HYBRID_BREAK();
61543
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV):
61544
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
61545
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61546
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
61547
        HYBRID_BREAK();
61548
      HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CV):
61549
        VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CV)
61550
        ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61551
        VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CV)
61552
        HYBRID_BREAK();
61553
      HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CV):
61554
        VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CV)
61555
        ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61556
        VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CV)
61557
        HYBRID_BREAK();
61558
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV):
61559
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
61560
        ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61561
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
61562
        HYBRID_BREAK();
61563
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CV):
61564
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CV)
61565
        ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61566
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CV)
61567
        HYBRID_BREAK();
61568
      HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CV):
61569
        VM_TRACE(ZEND_YIELD_SPEC_TMP_CV)
61570
        ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61571
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CV)
61572
        HYBRID_BREAK();
61573
      HYBRID_CASE(ZEND_BIND_LEXICAL_SPEC_TMP_CV):
61574
        VM_TRACE(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
61575
        ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61576
        VM_TRACE_OP_END(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
61577
        HYBRID_BREAK();
61578
      HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED):
61579
        VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
61580
        ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61581
        VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
61582
        HYBRID_BREAK();
61583
      HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED):
61584
        VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
61585
        ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61586
        VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
61587
        HYBRID_BREAK();
61588
      HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED):
61589
        VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
61590
        ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61591
        VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
61592
        HYBRID_BREAK();
61593
      HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED):
61594
        VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
61595
        ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61596
        VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
61597
        HYBRID_BREAK();
61598
      HYBRID_CASE(ZEND_POST_INC_SPEC_VAR):
61599
        VM_TRACE(ZEND_POST_INC_SPEC_VAR)
61600
        ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61601
        VM_TRACE_OP_END(ZEND_POST_INC_SPEC_VAR)
61602
        HYBRID_BREAK();
61603
      HYBRID_CASE(ZEND_POST_DEC_SPEC_VAR):
61604
        VM_TRACE(ZEND_POST_DEC_SPEC_VAR)
61605
        ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61606
        VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_VAR)
61607
        HYBRID_BREAK();
61608
      HYBRID_CASE(ZEND_RETURN_SPEC_VAR):
61609
        VM_TRACE(ZEND_RETURN_SPEC_VAR)
61610
{
61611
  USE_OPLINE
61612
  zval *retval_ptr;
61613
  zval *return_value;
61614
61615
  retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
61616
  return_value = EX(return_value);
61617
61618
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61619
    SAVE_OPLINE();
61620
    retval_ptr = ZVAL_UNDEFINED_OP1();
61621
    if (return_value) {
61622
      ZVAL_NULL(return_value);
61623
    }
61624
  } else if (!return_value) {
61625
    if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
61626
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61627
        SAVE_OPLINE();
61628
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
61629
      }
61630
    }
61631
  } else {
61632
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
61633
      ZVAL_COPY_VALUE(return_value, retval_ptr);
61634
      if (IS_VAR == IS_CONST) {
61635
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61636
          Z_ADDREF_P(return_value);
61637
        }
61638
      }
61639
    } else if (IS_VAR == IS_CV) {
61640
      do {
61641
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61642
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61643
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61644
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61645
              ZVAL_COPY_VALUE(return_value, retval_ptr);
61646
              if (GC_MAY_LEAK(ref)) {
61647
                SAVE_OPLINE();
61648
                gc_possible_root(ref);
61649
              }
61650
              ZVAL_NULL(retval_ptr);
61651
              break;
61652
            } else {
61653
              Z_ADDREF_P(retval_ptr);
61654
            }
61655
          } else {
61656
            retval_ptr = Z_REFVAL_P(retval_ptr);
61657
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61658
              Z_ADDREF_P(retval_ptr);
61659
            }
61660
          }
61661
        }
61662
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61663
      } while (0);
61664
    } else /* if (IS_VAR == IS_VAR) */ {
61665
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61666
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61667
61668
        retval_ptr = Z_REFVAL_P(retval_ptr);
61669
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61670
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61671
          efree_size(ref, sizeof(zend_reference));
61672
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61673
          Z_ADDREF_P(retval_ptr);
61674
        }
61675
      } else {
61676
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61677
      }
61678
    }
61679
  }
61680
61681
61682
61683
  goto zend_leave_helper_SPEC_LABEL;
61684
}
61685
61686
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_VAR)
61687
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR):
61688
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR)
61689
        ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61690
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_VAR)
61691
        HYBRID_BREAK();
61692
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR):
61693
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR)
61694
        ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61695
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_VAR)
61696
        HYBRID_BREAK();
61697
      HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR):
61698
        VM_TRACE(ZEND_SEND_USER_SPEC_VAR)
61699
        ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61700
        VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_VAR)
61701
        HYBRID_BREAK();
61702
      HYBRID_CASE(ZEND_CAST_SPEC_VAR):
61703
        VM_TRACE(ZEND_CAST_SPEC_VAR)
61704
        ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61705
        VM_TRACE_OP_END(ZEND_CAST_SPEC_VAR)
61706
        HYBRID_BREAK();
61707
      HYBRID_CASE(ZEND_FE_RESET_R_SPEC_VAR):
61708
        VM_TRACE(ZEND_FE_RESET_R_SPEC_VAR)
61709
        ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61710
        VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_VAR)
61711
        HYBRID_BREAK();
61712
      HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_VAR):
61713
        VM_TRACE(ZEND_FE_RESET_RW_SPEC_VAR)
61714
        ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61715
        VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_VAR)
61716
        HYBRID_BREAK();
61717
      HYBRID_CASE(ZEND_FE_FETCH_R_SPEC_VAR):
61718
        VM_TRACE(ZEND_FE_FETCH_R_SPEC_VAR)
61719
        ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61720
        VM_TRACE_OP_END(ZEND_FE_FETCH_R_SPEC_VAR)
61721
        HYBRID_BREAK();
61722
      HYBRID_CASE(ZEND_FE_FETCH_RW_SPEC_VAR):
61723
        VM_TRACE(ZEND_FE_FETCH_RW_SPEC_VAR)
61724
        ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61725
        VM_TRACE_OP_END(ZEND_FE_FETCH_RW_SPEC_VAR)
61726
        HYBRID_BREAK();
61727
      HYBRID_CASE(ZEND_JMP_SET_SPEC_VAR):
61728
        VM_TRACE(ZEND_JMP_SET_SPEC_VAR)
61729
        ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61730
        VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_VAR)
61731
        HYBRID_BREAK();
61732
      HYBRID_CASE(ZEND_COALESCE_SPEC_VAR):
61733
        VM_TRACE(ZEND_COALESCE_SPEC_VAR)
61734
        ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61735
        VM_TRACE_OP_END(ZEND_COALESCE_SPEC_VAR)
61736
        HYBRID_BREAK();
61737
      HYBRID_CASE(ZEND_JMP_NULL_SPEC_VAR):
61738
        VM_TRACE(ZEND_JMP_NULL_SPEC_VAR)
61739
        ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61740
        VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_VAR)
61741
        HYBRID_BREAK();
61742
      HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_VAR):
61743
        VM_TRACE(ZEND_QM_ASSIGN_SPEC_VAR)
61744
        ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61745
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_VAR)
61746
        HYBRID_BREAK();
61747
      HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR):
61748
        VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
61749
        ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61750
        VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
61751
        HYBRID_BREAK();
61752
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST):
61753
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
61754
        ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61755
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
61756
        HYBRID_BREAK();
61757
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CONST):
61758
        VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CONST)
61759
        ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61760
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CONST)
61761
        HYBRID_BREAK();
61762
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST):
61763
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
61764
        ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61765
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
61766
        HYBRID_BREAK();
61767
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST):
61768
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
61769
        ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61770
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
61771
        HYBRID_BREAK();
61772
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST):
61773
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
61774
        ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61775
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
61776
        HYBRID_BREAK();
61777
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CONST):
61778
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
61779
        ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61780
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
61781
        HYBRID_BREAK();
61782
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST):
61783
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
61784
        ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61785
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
61786
        HYBRID_BREAK();
61787
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST):
61788
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
61789
        ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61790
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
61791
        HYBRID_BREAK();
61792
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST):
61793
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
61794
        ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61795
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
61796
        HYBRID_BREAK();
61797
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST):
61798
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
61799
        ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61800
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
61801
        HYBRID_BREAK();
61802
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST):
61803
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
61804
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61805
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
61806
        HYBRID_BREAK();
61807
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST):
61808
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
61809
        ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61810
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
61811
        HYBRID_BREAK();
61812
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST):
61813
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
61814
        ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61815
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
61816
        HYBRID_BREAK();
61817
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST):
61818
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
61819
        ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61820
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
61821
        HYBRID_BREAK();
61822
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST):
61823
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
61824
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61825
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
61826
        HYBRID_BREAK();
61827
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST):
61828
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
61829
        ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61830
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
61831
        HYBRID_BREAK();
61832
      HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST):
61833
        VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
61834
        ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61835
        VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
61836
        HYBRID_BREAK();
61837
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST):
61838
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
61839
        ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61840
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
61841
        HYBRID_BREAK();
61842
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP):
61843
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
61844
        ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61845
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
61846
        HYBRID_BREAK();
61847
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR):
61848
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
61849
        ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61850
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
61851
        HYBRID_BREAK();
61852
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV):
61853
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
61854
        ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61855
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
61856
        HYBRID_BREAK();
61857
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST):
61858
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
61859
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61860
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
61861
        HYBRID_BREAK();
61862
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP):
61863
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
61864
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61865
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
61866
        HYBRID_BREAK();
61867
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR):
61868
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
61869
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61870
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
61871
        HYBRID_BREAK();
61872
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV):
61873
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
61874
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61875
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
61876
        HYBRID_BREAK();
61877
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED):
61878
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
61879
        ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61880
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
61881
        HYBRID_BREAK();
61882
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED):
61883
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
61884
        ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61885
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
61886
        HYBRID_BREAK();
61887
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR):
61888
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
61889
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61890
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
61891
        HYBRID_BREAK();
61892
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV):
61893
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
61894
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61895
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
61896
        HYBRID_BREAK();
61897
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST):
61898
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
61899
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61900
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
61901
        HYBRID_BREAK();
61902
      HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST):
61903
        VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST)
61904
        ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61905
        VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_CONST)
61906
        HYBRID_BREAK();
61907
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST):
61908
        VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
61909
        ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61910
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
61911
        HYBRID_BREAK();
61912
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST):
61913
        VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
61914
        ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61915
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
61916
        HYBRID_BREAK();
61917
      HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_CONST):
61918
        VM_TRACE(ZEND_SEND_REF_SPEC_VAR_CONST)
61919
        ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61920
        VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_CONST)
61921
        HYBRID_BREAK();
61922
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST):
61923
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
61924
        ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61925
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
61926
        HYBRID_BREAK();
61927
      HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST):
61928
        VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
61929
        ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61930
        VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
61931
        HYBRID_BREAK();
61932
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST):
61933
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
61934
        ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61935
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
61936
        HYBRID_BREAK();
61937
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST):
61938
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
61939
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61940
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
61941
        HYBRID_BREAK();
61942
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CONST):
61943
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
61944
        ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61945
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
61946
        HYBRID_BREAK();
61947
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CONST):
61948
        VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CONST)
61949
        ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61950
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CONST)
61951
        HYBRID_BREAK();
61952
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CONST):
61953
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
61954
        ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61955
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
61956
        HYBRID_BREAK();
61957
      HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CONST):
61958
        VM_TRACE(ZEND_YIELD_SPEC_VAR_CONST)
61959
        ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61960
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CONST)
61961
        HYBRID_BREAK();
61962
      HYBRID_CASE(ZEND_IN_ARRAY_SPEC_VAR_CONST):
61963
        VM_TRACE(ZEND_IN_ARRAY_SPEC_VAR_CONST)
61964
        ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61965
        VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_VAR_CONST)
61966
        HYBRID_BREAK();
61967
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV):
61968
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
61969
        ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61970
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
61971
        HYBRID_BREAK();
61972
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR):
61973
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
61974
        ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61975
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
61976
        HYBRID_BREAK();
61977
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR):
61978
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
61979
        ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61980
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
61981
        HYBRID_BREAK();
61982
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR):
61983
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
61984
        ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61985
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
61986
        HYBRID_BREAK();
61987
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR):
61988
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
61989
        ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61990
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
61991
        HYBRID_BREAK();
61992
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR):
61993
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
61994
        ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61995
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
61996
        HYBRID_BREAK();
61997
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR):
61998
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
61999
        ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62000
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
62001
        HYBRID_BREAK();
62002
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR):
62003
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
62004
        ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62005
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
62006
        HYBRID_BREAK();
62007
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR):
62008
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
62009
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62010
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
62011
        HYBRID_BREAK();
62012
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR):
62013
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
62014
        ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62015
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
62016
        HYBRID_BREAK();
62017
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR):
62018
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
62019
        ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62020
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
62021
        HYBRID_BREAK();
62022
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR):
62023
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
62024
        ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62025
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
62026
        HYBRID_BREAK();
62027
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR):
62028
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
62029
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62030
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
62031
        HYBRID_BREAK();
62032
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR):
62033
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
62034
        ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62035
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
62036
        HYBRID_BREAK();
62037
      HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR):
62038
        VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
62039
        ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62040
        VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
62041
        HYBRID_BREAK();
62042
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST):
62043
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
62044
        ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62045
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
62046
        HYBRID_BREAK();
62047
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP):
62048
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
62049
        ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62050
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
62051
        HYBRID_BREAK();
62052
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR):
62053
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62054
        ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62055
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62056
        HYBRID_BREAK();
62057
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV):
62058
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
62059
        ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62060
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
62061
        HYBRID_BREAK();
62062
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST):
62063
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
62064
        ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62065
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
62066
        HYBRID_BREAK();
62067
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP):
62068
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
62069
        ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62070
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
62071
        HYBRID_BREAK();
62072
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR):
62073
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62074
        ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62075
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62076
        HYBRID_BREAK();
62077
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV):
62078
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
62079
        ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62080
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
62081
        HYBRID_BREAK();
62082
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR):
62083
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62084
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62085
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62086
        HYBRID_BREAK();
62087
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV):
62088
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
62089
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62090
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
62091
        HYBRID_BREAK();
62092
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR):
62093
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
62094
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62095
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
62096
        HYBRID_BREAK();
62097
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR):
62098
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
62099
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62100
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
62101
        HYBRID_BREAK();
62102
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR):
62103
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
62104
        ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62105
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
62106
        HYBRID_BREAK();
62107
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR):
62108
        VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
62109
        ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62110
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
62111
        HYBRID_BREAK();
62112
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR):
62113
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
62114
        ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62115
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
62116
        HYBRID_BREAK();
62117
      HYBRID_CASE(ZEND_YIELD_SPEC_VAR_TMPVAR):
62118
        VM_TRACE(ZEND_YIELD_SPEC_VAR_TMPVAR)
62119
        ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62120
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_TMPVAR)
62121
        HYBRID_BREAK();
62122
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP):
62123
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
62124
        ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62125
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
62126
        HYBRID_BREAK();
62127
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_TMP):
62128
        VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_TMP)
62129
        ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62130
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_TMP)
62131
        HYBRID_BREAK();
62132
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP):
62133
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
62134
        ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62135
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
62136
        HYBRID_BREAK();
62137
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED):
62138
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
62139
        ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62140
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
62141
        HYBRID_BREAK();
62142
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED):
62143
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
62144
        ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62145
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
62146
        HYBRID_BREAK();
62147
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR):
62148
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
62149
        ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62150
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
62151
        HYBRID_BREAK();
62152
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_VAR):
62153
        VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_VAR)
62154
        ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62155
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_VAR)
62156
        HYBRID_BREAK();
62157
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR):
62158
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
62159
        ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62160
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
62161
        HYBRID_BREAK();
62162
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED):
62163
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
62164
        ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62165
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
62166
        HYBRID_BREAK();
62167
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED):
62168
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
62169
        ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62170
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
62171
        HYBRID_BREAK();
62172
      HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_VAR):
62173
        VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
62174
        ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62175
        VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
62176
        HYBRID_BREAK();
62177
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED):
62178
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
62179
        ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62180
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
62181
        HYBRID_BREAK();
62182
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED):
62183
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
62184
        ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62185
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
62186
        HYBRID_BREAK();
62187
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED):
62188
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
62189
        ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62190
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
62191
        HYBRID_BREAK();
62192
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED):
62193
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
62194
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62195
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
62196
        HYBRID_BREAK();
62197
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST):
62198
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
62199
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62200
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
62201
        HYBRID_BREAK();
62202
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP):
62203
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
62204
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62205
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
62206
        HYBRID_BREAK();
62207
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR):
62208
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
62209
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62210
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
62211
        HYBRID_BREAK();
62212
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV):
62213
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
62214
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62215
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
62216
        HYBRID_BREAK();
62217
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED):
62218
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
62219
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62220
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
62221
        HYBRID_BREAK();
62222
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED):
62223
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
62224
        ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62225
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
62226
        HYBRID_BREAK();
62227
      HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_UNUSED):
62228
        VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
62229
        ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62230
        VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
62231
        HYBRID_BREAK();
62232
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED):
62233
        VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
62234
        ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62235
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
62236
        HYBRID_BREAK();
62237
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED):
62238
        VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
62239
        ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62240
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
62241
        HYBRID_BREAK();
62242
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK):
62243
        VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
62244
        ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62245
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
62246
        HYBRID_BREAK();
62247
      HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_UNUSED):
62248
        VM_TRACE(ZEND_SEND_REF_SPEC_VAR_UNUSED)
62249
        ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62250
        VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_UNUSED)
62251
        HYBRID_BREAK();
62252
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED):
62253
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
62254
        ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62255
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
62256
        HYBRID_BREAK();
62257
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK):
62258
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
62259
        ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62260
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
62261
        HYBRID_BREAK();
62262
      HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED):
62263
        VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
62264
        ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62265
        VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
62266
        HYBRID_BREAK();
62267
      HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED):
62268
        VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED)
62269
        ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62270
        VM_TRACE_OP_END(ZEND_NEW_SPEC_VAR_UNUSED)
62271
        HYBRID_BREAK();
62272
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED):
62273
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
62274
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62275
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
62276
        HYBRID_BREAK();
62277
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED):
62278
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
62279
        ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62280
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
62281
        HYBRID_BREAK();
62282
      HYBRID_CASE(ZEND_SEPARATE_SPEC_VAR_UNUSED):
62283
        VM_TRACE(ZEND_SEPARATE_SPEC_VAR_UNUSED)
62284
        ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62285
        VM_TRACE_OP_END(ZEND_SEPARATE_SPEC_VAR_UNUSED)
62286
        HYBRID_BREAK();
62287
      HYBRID_CASE(ZEND_YIELD_SPEC_VAR_UNUSED):
62288
        VM_TRACE(ZEND_YIELD_SPEC_VAR_UNUSED)
62289
        ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62290
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_UNUSED)
62291
        HYBRID_BREAK();
62292
      HYBRID_CASE(ZEND_MAKE_REF_SPEC_VAR_UNUSED):
62293
        VM_TRACE(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
62294
        ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62295
        VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
62296
        HYBRID_BREAK();
62297
      HYBRID_CASE(ZEND_GET_TYPE_SPEC_VAR_UNUSED):
62298
        VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
62299
        ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62300
        VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
62301
        HYBRID_BREAK();
62302
      HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED):
62303
        VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
62304
        ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62305
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
62306
        HYBRID_BREAK();
62307
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV):
62308
        VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV)
62309
        ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62310
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CV)
62311
        HYBRID_BREAK();
62312
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV):
62313
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
62314
        ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62315
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
62316
        HYBRID_BREAK();
62317
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV):
62318
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
62319
        ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62320
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
62321
        HYBRID_BREAK();
62322
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CV):
62323
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CV)
62324
        ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62325
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CV)
62326
        HYBRID_BREAK();
62327
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV):
62328
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
62329
        ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62330
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
62331
        HYBRID_BREAK();
62332
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CV):
62333
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
62334
        ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62335
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
62336
        HYBRID_BREAK();
62337
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CV):
62338
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
62339
        ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62340
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
62341
        HYBRID_BREAK();
62342
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV):
62343
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
62344
        ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62345
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
62346
        HYBRID_BREAK();
62347
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV):
62348
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
62349
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62350
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
62351
        HYBRID_BREAK();
62352
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV):
62353
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
62354
        ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62355
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
62356
        HYBRID_BREAK();
62357
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV):
62358
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
62359
        ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62360
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
62361
        HYBRID_BREAK();
62362
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV):
62363
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
62364
        ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62365
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
62366
        HYBRID_BREAK();
62367
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV):
62368
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
62369
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62370
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
62371
        HYBRID_BREAK();
62372
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV):
62373
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
62374
        ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62375
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
62376
        HYBRID_BREAK();
62377
      HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CV):
62378
        VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
62379
        ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62380
        VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
62381
        HYBRID_BREAK();
62382
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST):
62383
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
62384
        ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62385
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
62386
        HYBRID_BREAK();
62387
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP):
62388
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
62389
        ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62390
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
62391
        HYBRID_BREAK();
62392
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR):
62393
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
62394
        ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62395
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
62396
        HYBRID_BREAK();
62397
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV):
62398
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
62399
        ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62400
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
62401
        HYBRID_BREAK();
62402
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST):
62403
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
62404
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62405
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
62406
        HYBRID_BREAK();
62407
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP):
62408
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
62409
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62410
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
62411
        HYBRID_BREAK();
62412
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR):
62413
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
62414
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62415
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
62416
        HYBRID_BREAK();
62417
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV):
62418
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
62419
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62420
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
62421
        HYBRID_BREAK();
62422
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED):
62423
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
62424
        ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62425
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
62426
        HYBRID_BREAK();
62427
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED):
62428
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
62429
        ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62430
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
62431
        HYBRID_BREAK();
62432
      HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_CV):
62433
        VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_CV)
62434
        ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62435
        VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_CV)
62436
        HYBRID_BREAK();
62437
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR):
62438
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
62439
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62440
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
62441
        HYBRID_BREAK();
62442
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV):
62443
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
62444
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62445
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
62446
        HYBRID_BREAK();
62447
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV):
62448
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
62449
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62450
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
62451
        HYBRID_BREAK();
62452
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV):
62453
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
62454
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62455
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
62456
        HYBRID_BREAK();
62457
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CV):
62458
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CV)
62459
        ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62460
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CV)
62461
        HYBRID_BREAK();
62462
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CV):
62463
        VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CV)
62464
        ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62465
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CV)
62466
        HYBRID_BREAK();
62467
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CV):
62468
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CV)
62469
        ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62470
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CV)
62471
        HYBRID_BREAK();
62472
      HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CV):
62473
        VM_TRACE(ZEND_YIELD_SPEC_VAR_CV)
62474
        ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62475
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CV)
62476
        HYBRID_BREAK();
62477
      HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED):
62478
        VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
62479
        ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62480
        VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
62481
        HYBRID_BREAK();
62482
      HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED):
62483
        VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
62484
        ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62485
        VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
62486
        HYBRID_BREAK();
62487
      HYBRID_CASE(ZEND_CLONE_SPEC_UNUSED):
62488
        VM_TRACE(ZEND_CLONE_SPEC_UNUSED)
62489
        ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62490
        VM_TRACE_OP_END(ZEND_CLONE_SPEC_UNUSED)
62491
        HYBRID_BREAK();
62492
      HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED):
62493
        VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
62494
        ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62495
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
62496
        HYBRID_BREAK();
62497
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST):
62498
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
62499
        ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62500
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
62501
        HYBRID_BREAK();
62502
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST):
62503
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
62504
        ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62505
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
62506
        HYBRID_BREAK();
62507
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST):
62508
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
62509
        ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62510
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
62511
        HYBRID_BREAK();
62512
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST):
62513
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
62514
        ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62515
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
62516
        HYBRID_BREAK();
62517
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST):
62518
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
62519
        ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62520
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
62521
        HYBRID_BREAK();
62522
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST):
62523
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
62524
        ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62525
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
62526
        HYBRID_BREAK();
62527
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST):
62528
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
62529
        ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62530
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
62531
        HYBRID_BREAK();
62532
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST):
62533
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
62534
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62535
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
62536
        HYBRID_BREAK();
62537
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST):
62538
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
62539
        ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62540
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
62541
        HYBRID_BREAK();
62542
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST):
62543
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
62544
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62545
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
62546
        HYBRID_BREAK();
62547
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP):
62548
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
62549
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62550
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
62551
        HYBRID_BREAK();
62552
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR):
62553
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
62554
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62555
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
62556
        HYBRID_BREAK();
62557
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV):
62558
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
62559
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62560
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
62561
        HYBRID_BREAK();
62562
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR):
62563
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
62564
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62565
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
62566
        HYBRID_BREAK();
62567
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV):
62568
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
62569
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62570
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
62571
        HYBRID_BREAK();
62572
      HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST):
62573
        VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
62574
        ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62575
        VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
62576
        HYBRID_BREAK();
62577
      HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST):
62578
        VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
62579
        ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62580
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
62581
        HYBRID_BREAK();
62582
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST):
62583
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
62584
        ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62585
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
62586
        HYBRID_BREAK();
62587
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST):
62588
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
62589
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62590
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
62591
        HYBRID_BREAK();
62592
      HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST):
62593
        VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
62594
        ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62595
        VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
62596
        HYBRID_BREAK();
62597
      HYBRID_CASE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST):
62598
        VM_TRACE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
62599
        ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62600
        VM_TRACE_OP_END(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
62601
        HYBRID_BREAK();
62602
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST):
62603
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
62604
        ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62605
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
62606
        HYBRID_BREAK();
62607
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST):
62608
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
62609
        ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62610
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
62611
        HYBRID_BREAK();
62612
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST):
62613
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
62614
        ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62615
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
62616
        HYBRID_BREAK();
62617
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST):
62618
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
62619
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62620
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
62621
        HYBRID_BREAK();
62622
      HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CONST):
62623
        VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CONST)
62624
        ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62625
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CONST)
62626
        HYBRID_BREAK();
62627
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV):
62628
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
62629
        ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62630
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
62631
        HYBRID_BREAK();
62632
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR):
62633
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
62634
        ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62635
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
62636
        HYBRID_BREAK();
62637
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR):
62638
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
62639
        ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62640
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
62641
        HYBRID_BREAK();
62642
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR):
62643
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
62644
        ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62645
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
62646
        HYBRID_BREAK();
62647
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR):
62648
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
62649
        ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62650
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
62651
        HYBRID_BREAK();
62652
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR):
62653
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
62654
        ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62655
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
62656
        HYBRID_BREAK();
62657
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR):
62658
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
62659
        ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62660
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
62661
        HYBRID_BREAK();
62662
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR):
62663
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
62664
        ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62665
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
62666
        HYBRID_BREAK();
62667
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR):
62668
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
62669
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62670
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
62671
        HYBRID_BREAK();
62672
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR):
62673
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
62674
        ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62675
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
62676
        HYBRID_BREAK();
62677
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST):
62678
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
62679
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62680
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
62681
        HYBRID_BREAK();
62682
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP):
62683
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
62684
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62685
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
62686
        HYBRID_BREAK();
62687
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
62688
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62689
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62690
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62691
        HYBRID_BREAK();
62692
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
62693
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62694
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62695
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62696
        HYBRID_BREAK();
62697
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
62698
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62699
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62700
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62701
        HYBRID_BREAK();
62702
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
62703
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62704
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62705
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62706
        HYBRID_BREAK();
62707
      HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR):
62708
        VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
62709
        ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62710
        VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
62711
        HYBRID_BREAK();
62712
      HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR):
62713
        VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
62714
        ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62715
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
62716
        HYBRID_BREAK();
62717
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR):
62718
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62719
        ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62720
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62721
        HYBRID_BREAK();
62722
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR):
62723
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62724
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62725
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62726
        HYBRID_BREAK();
62727
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR):
62728
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
62729
        ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62730
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
62731
        HYBRID_BREAK();
62732
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR):
62733
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
62734
        ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62735
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
62736
        HYBRID_BREAK();
62737
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR):
62738
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
62739
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62740
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
62741
        HYBRID_BREAK();
62742
      HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_TMPVAR):
62743
        VM_TRACE(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
62744
        ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62745
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
62746
        HYBRID_BREAK();
62747
      HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED):
62748
        VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
62749
        ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62750
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
62751
        HYBRID_BREAK();
62752
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED):
62753
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
62754
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62755
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
62756
        HYBRID_BREAK();
62757
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED):
62758
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
62759
        ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62760
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
62761
        HYBRID_BREAK();
62762
      HYBRID_CASE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED):
62763
        VM_TRACE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
62764
        ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62765
        VM_TRACE_OP_END(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
62766
        HYBRID_BREAK();
62767
      HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED):
62768
        VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
62769
        ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62770
        VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
62771
        HYBRID_BREAK();
62772
      HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK):
62773
        VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
62774
        ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62775
        VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
62776
        HYBRID_BREAK();
62777
      HYBRID_CASE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED):
62778
        VM_TRACE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
62779
        ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62780
        VM_TRACE_OP_END(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
62781
        HYBRID_BREAK();
62782
      HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED):
62783
        VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED)
62784
        ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62785
        VM_TRACE_OP_END(ZEND_NEW_SPEC_UNUSED_UNUSED)
62786
        HYBRID_BREAK();
62787
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED):
62788
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
62789
        ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62790
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
62791
        HYBRID_BREAK();
62792
      HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_UNUSED):
62793
        VM_TRACE(ZEND_YIELD_SPEC_UNUSED_UNUSED)
62794
        ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62795
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_UNUSED)
62796
        HYBRID_BREAK();
62797
      HYBRID_CASE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED):
62798
        VM_TRACE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
62799
        ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62800
        VM_TRACE_OP_END(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
62801
        HYBRID_BREAK();
62802
      HYBRID_CASE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED):
62803
        VM_TRACE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
62804
        ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62805
        VM_TRACE_OP_END(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
62806
        HYBRID_BREAK();
62807
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED):
62808
        VM_TRACE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
62809
        ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62810
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
62811
        HYBRID_BREAK();
62812
      HYBRID_CASE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED):
62813
        VM_TRACE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
62814
        ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62815
        VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
62816
        HYBRID_BREAK();
62817
      HYBRID_CASE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED):
62818
        VM_TRACE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
62819
        ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62820
        VM_TRACE_OP_END(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
62821
        HYBRID_BREAK();
62822
      HYBRID_CASE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED):
62823
        VM_TRACE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
62824
        ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62825
        VM_TRACE_OP_END(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
62826
        HYBRID_BREAK();
62827
      HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED):
62828
        VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
62829
        ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62830
        VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
62831
        HYBRID_BREAK();
62832
      HYBRID_CASE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED):
62833
        VM_TRACE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
62834
        ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62835
        VM_TRACE_OP_END(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
62836
        HYBRID_BREAK();
62837
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED):
62838
        VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
62839
        ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62840
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
62841
        HYBRID_BREAK();
62842
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER):
62843
        VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER)
62844
        ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62845
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER)
62846
        HYBRID_BREAK();
62847
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV):
62848
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
62849
        ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62850
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
62851
        HYBRID_BREAK();
62852
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV):
62853
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
62854
        ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62855
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
62856
        HYBRID_BREAK();
62857
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV):
62858
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
62859
        ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62860
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
62861
        HYBRID_BREAK();
62862
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV):
62863
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
62864
        ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62865
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
62866
        HYBRID_BREAK();
62867
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV):
62868
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
62869
        ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62870
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
62871
        HYBRID_BREAK();
62872
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV):
62873
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
62874
        ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62875
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
62876
        HYBRID_BREAK();
62877
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV):
62878
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
62879
        ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62880
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
62881
        HYBRID_BREAK();
62882
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV):
62883
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
62884
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62885
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
62886
        HYBRID_BREAK();
62887
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV):
62888
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
62889
        ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62890
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
62891
        HYBRID_BREAK();
62892
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST):
62893
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
62894
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62895
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
62896
        HYBRID_BREAK();
62897
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP):
62898
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
62899
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62900
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
62901
        HYBRID_BREAK();
62902
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR):
62903
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
62904
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62905
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
62906
        HYBRID_BREAK();
62907
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV):
62908
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
62909
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62910
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
62911
        HYBRID_BREAK();
62912
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR):
62913
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
62914
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62915
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
62916
        HYBRID_BREAK();
62917
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV):
62918
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
62919
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62920
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
62921
        HYBRID_BREAK();
62922
      HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CV):
62923
        VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
62924
        ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62925
        VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
62926
        HYBRID_BREAK();
62927
      HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV):
62928
        VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
62929
        ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62930
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
62931
        HYBRID_BREAK();
62932
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV):
62933
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
62934
        ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62935
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
62936
        HYBRID_BREAK();
62937
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV):
62938
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
62939
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62940
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
62941
        HYBRID_BREAK();
62942
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV):
62943
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
62944
        ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62945
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
62946
        HYBRID_BREAK();
62947
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV):
62948
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
62949
        ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62950
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
62951
        HYBRID_BREAK();
62952
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV):
62953
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
62954
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62955
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
62956
        HYBRID_BREAK();
62957
      HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CV):
62958
        VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CV)
62959
        ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62960
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CV)
62961
        HYBRID_BREAK();
62962
      HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CV):
62963
        VM_TRACE(ZEND_BOOL_NOT_SPEC_CV)
62964
        ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62965
        VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CV)
62966
        HYBRID_BREAK();
62967
      HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED):
62968
        VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
62969
        ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62970
        VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
62971
        HYBRID_BREAK();
62972
      HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED):
62973
        VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
62974
        ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62975
        VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
62976
        HYBRID_BREAK();
62977
      HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED):
62978
        VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
62979
        ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62980
        VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
62981
        HYBRID_BREAK();
62982
      HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED):
62983
        VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
62984
        ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62985
        VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
62986
        HYBRID_BREAK();
62987
      HYBRID_CASE(ZEND_POST_INC_SPEC_CV):
62988
        VM_TRACE(ZEND_POST_INC_SPEC_CV)
62989
        ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62990
        VM_TRACE_OP_END(ZEND_POST_INC_SPEC_CV)
62991
        HYBRID_BREAK();
62992
      HYBRID_CASE(ZEND_POST_DEC_SPEC_CV):
62993
        VM_TRACE(ZEND_POST_DEC_SPEC_CV)
62994
        ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62995
        VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_CV)
62996
        HYBRID_BREAK();
62997
      HYBRID_CASE(ZEND_ECHO_SPEC_CV):
62998
        VM_TRACE(ZEND_ECHO_SPEC_CV)
62999
        ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63000
        VM_TRACE_OP_END(ZEND_ECHO_SPEC_CV)
63001
        HYBRID_BREAK();
63002
      HYBRID_CASE(ZEND_JMPZ_SPEC_CV):
63003
        VM_TRACE(ZEND_JMPZ_SPEC_CV)
63004
        ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63005
        VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CV)
63006
        HYBRID_BREAK();
63007
      HYBRID_CASE(ZEND_JMPNZ_SPEC_CV):
63008
        VM_TRACE(ZEND_JMPNZ_SPEC_CV)
63009
        ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63010
        VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CV)
63011
        HYBRID_BREAK();
63012
      HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CV):
63013
        VM_TRACE(ZEND_JMPZ_EX_SPEC_CV)
63014
        ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63015
        VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CV)
63016
        HYBRID_BREAK();
63017
      HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CV):
63018
        VM_TRACE(ZEND_JMPNZ_EX_SPEC_CV)
63019
        ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63020
        VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CV)
63021
        HYBRID_BREAK();
63022
      HYBRID_CASE(ZEND_RETURN_SPEC_CV):
63023
        VM_TRACE(ZEND_RETURN_SPEC_CV)
63024
{
63025
  USE_OPLINE
63026
  zval *retval_ptr;
63027
  zval *return_value;
63028
63029
  retval_ptr = EX_VAR(opline->op1.var);
63030
  return_value = EX(return_value);
63031
63032
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
63033
    SAVE_OPLINE();
63034
    retval_ptr = ZVAL_UNDEFINED_OP1();
63035
    if (return_value) {
63036
      ZVAL_NULL(return_value);
63037
    }
63038
  } else if (!return_value) {
63039
    if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
63040
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
63041
        SAVE_OPLINE();
63042
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
63043
      }
63044
    }
63045
  } else {
63046
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
63047
      ZVAL_COPY_VALUE(return_value, retval_ptr);
63048
      if (IS_CV == IS_CONST) {
63049
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
63050
          Z_ADDREF_P(return_value);
63051
        }
63052
      }
63053
    } else if (IS_CV == IS_CV) {
63054
      do {
63055
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
63056
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
63057
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
63058
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
63059
              ZVAL_COPY_VALUE(return_value, retval_ptr);
63060
              if (GC_MAY_LEAK(ref)) {
63061
                SAVE_OPLINE();
63062
                gc_possible_root(ref);
63063
              }
63064
              ZVAL_NULL(retval_ptr);
63065
              break;
63066
            } else {
63067
              Z_ADDREF_P(retval_ptr);
63068
            }
63069
          } else {
63070
            retval_ptr = Z_REFVAL_P(retval_ptr);
63071
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
63072
              Z_ADDREF_P(retval_ptr);
63073
            }
63074
          }
63075
        }
63076
        ZVAL_COPY_VALUE(return_value, retval_ptr);
63077
      } while (0);
63078
    } else /* if (IS_CV == IS_VAR) */ {
63079
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
63080
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
63081
63082
        retval_ptr = Z_REFVAL_P(retval_ptr);
63083
        ZVAL_COPY_VALUE(return_value, retval_ptr);
63084
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
63085
          efree_size(ref, sizeof(zend_reference));
63086
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
63087
          Z_ADDREF_P(retval_ptr);
63088
        }
63089
      } else {
63090
        ZVAL_COPY_VALUE(return_value, retval_ptr);
63091
      }
63092
    }
63093
  }
63094
63095
63096
63097
  goto zend_leave_helper_SPEC_LABEL;
63098
}
63099
63100
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_CV)
63101
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CV):
63102
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV)
63103
        ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63104
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CV)
63105
        HYBRID_BREAK();
63106
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV):
63107
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV)
63108
        ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63109
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CV)
63110
        HYBRID_BREAK();
63111
      HYBRID_CASE(ZEND_THROW_SPEC_CV):
63112
        VM_TRACE(ZEND_THROW_SPEC_CV)
63113
        ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63114
        VM_TRACE_OP_END(ZEND_THROW_SPEC_CV)
63115
        HYBRID_BREAK();
63116
      HYBRID_CASE(ZEND_SEND_USER_SPEC_CV):
63117
        VM_TRACE(ZEND_SEND_USER_SPEC_CV)
63118
        ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63119
        VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV)
63120
        HYBRID_BREAK();
63121
      HYBRID_CASE(ZEND_BOOL_SPEC_CV):
63122
        VM_TRACE(ZEND_BOOL_SPEC_CV)
63123
        ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63124
        VM_TRACE_OP_END(ZEND_BOOL_SPEC_CV)
63125
        HYBRID_BREAK();
63126
      HYBRID_CASE(ZEND_CLONE_SPEC_CV):
63127
        VM_TRACE(ZEND_CLONE_SPEC_CV)
63128
        ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63129
        VM_TRACE_OP_END(ZEND_CLONE_SPEC_CV)
63130
        HYBRID_BREAK();
63131
      HYBRID_CASE(ZEND_CAST_SPEC_CV):
63132
        VM_TRACE(ZEND_CAST_SPEC_CV)
63133
        ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63134
        VM_TRACE_OP_END(ZEND_CAST_SPEC_CV)
63135
        HYBRID_BREAK();
63136
      HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV):
63137
        VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
63138
        ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63139
        VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
63140
        HYBRID_BREAK();
63141
      HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CV):
63142
        VM_TRACE(ZEND_FE_RESET_R_SPEC_CV)
63143
        ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63144
        VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CV)
63145
        HYBRID_BREAK();
63146
      HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CV):
63147
        VM_TRACE(ZEND_FE_RESET_RW_SPEC_CV)
63148
        ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63149
        VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CV)
63150
        HYBRID_BREAK();
63151
      HYBRID_CASE(ZEND_JMP_SET_SPEC_CV):
63152
        VM_TRACE(ZEND_JMP_SET_SPEC_CV)
63153
        ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63154
        VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CV)
63155
        HYBRID_BREAK();
63156
      HYBRID_CASE(ZEND_COALESCE_SPEC_CV):
63157
        VM_TRACE(ZEND_COALESCE_SPEC_CV)
63158
        ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63159
        VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CV)
63160
        HYBRID_BREAK();
63161
      HYBRID_CASE(ZEND_JMP_NULL_SPEC_CV):
63162
        VM_TRACE(ZEND_JMP_NULL_SPEC_CV)
63163
        ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63164
        VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CV)
63165
        HYBRID_BREAK();
63166
      HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CV):
63167
        VM_TRACE(ZEND_QM_ASSIGN_SPEC_CV)
63168
        ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63169
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CV)
63170
        HYBRID_BREAK();
63171
      HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CV):
63172
        VM_TRACE(ZEND_YIELD_FROM_SPEC_CV)
63173
        ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63174
        VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CV)
63175
        HYBRID_BREAK();
63176
      HYBRID_CASE(ZEND_STRLEN_SPEC_CV):
63177
        VM_TRACE(ZEND_STRLEN_SPEC_CV)
63178
        ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63179
        VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CV)
63180
        HYBRID_BREAK();
63181
      HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CV):
63182
        VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV)
63183
        ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63184
        VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CV)
63185
        HYBRID_BREAK();
63186
      HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_CV):
63187
        VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_CV)
63188
        ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63189
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_CV)
63190
        HYBRID_BREAK();
63191
      HYBRID_CASE(ZEND_BIND_STATIC_SPEC_CV):
63192
        VM_TRACE(ZEND_BIND_STATIC_SPEC_CV)
63193
        ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63194
        VM_TRACE_OP_END(ZEND_BIND_STATIC_SPEC_CV)
63195
        HYBRID_BREAK();
63196
      HYBRID_CASE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV):
63197
        VM_TRACE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
63198
        ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63199
        VM_TRACE_OP_END(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
63200
        HYBRID_BREAK();
63201
      HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
63202
        VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63203
        ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63204
        VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63205
        HYBRID_BREAK();
63206
      HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
63207
        VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63208
        ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63209
        VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63210
        HYBRID_BREAK();
63211
      HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED):
63212
        VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
63213
        ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63214
        VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
63215
        HYBRID_BREAK();
63216
      HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED):
63217
        VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
63218
        ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63219
        VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
63220
        HYBRID_BREAK();
63221
      HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
63222
        VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63223
        ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63224
        VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63225
        HYBRID_BREAK();
63226
      HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
63227
        VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63228
        ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63229
        VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63230
        HYBRID_BREAK();
63231
      HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED):
63232
        VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
63233
        ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63234
        VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
63235
        HYBRID_BREAK();
63236
      HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED):
63237
        VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
63238
        ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63239
        VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
63240
        HYBRID_BREAK();
63241
      HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV):
63242
        VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
63243
        ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63244
        VM_TRACE_OP_END(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
63245
        HYBRID_BREAK();
63246
      HYBRID_CASE(ZEND_POST_INC_LONG_SPEC_CV):
63247
        VM_TRACE(ZEND_POST_INC_LONG_SPEC_CV)
63248
        ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63249
        VM_TRACE_OP_END(ZEND_POST_INC_LONG_SPEC_CV)
63250
        HYBRID_BREAK();
63251
      HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV):
63252
        VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
63253
        ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63254
        VM_TRACE_OP_END(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
63255
        HYBRID_BREAK();
63256
      HYBRID_CASE(ZEND_POST_DEC_LONG_SPEC_CV):
63257
        VM_TRACE(ZEND_POST_DEC_LONG_SPEC_CV)
63258
        ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63259
        VM_TRACE_OP_END(ZEND_POST_DEC_LONG_SPEC_CV)
63260
        HYBRID_BREAK();
63261
      HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_CV):
63262
        VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
63263
        ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63264
        VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
63265
        HYBRID_BREAK();
63266
      HYBRID_CASE(ZEND_DIV_SPEC_CV_CONST):
63267
        VM_TRACE(ZEND_DIV_SPEC_CV_CONST)
63268
        ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63269
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CONST)
63270
        HYBRID_BREAK();
63271
      HYBRID_CASE(ZEND_POW_SPEC_CV_CONST):
63272
        VM_TRACE(ZEND_POW_SPEC_CV_CONST)
63273
        ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63274
        VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CONST)
63275
        HYBRID_BREAK();
63276
      HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CONST):
63277
        VM_TRACE(ZEND_CONCAT_SPEC_CV_CONST)
63278
        ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63279
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CONST)
63280
        HYBRID_BREAK();
63281
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CONST):
63282
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
63283
        ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63284
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
63285
        HYBRID_BREAK();
63286
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST):
63287
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
63288
        ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63289
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
63290
        HYBRID_BREAK();
63291
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST):
63292
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST)
63293
        ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63294
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST)
63295
        HYBRID_BREAK();
63296
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ):
63297
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
63298
        ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63299
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
63300
        HYBRID_BREAK();
63301
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ):
63302
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
63303
        ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63304
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
63305
        HYBRID_BREAK();
63306
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST):
63307
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
63308
        ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63309
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
63310
        HYBRID_BREAK();
63311
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ):
63312
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
63313
        ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63314
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
63315
        HYBRID_BREAK();
63316
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ):
63317
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
63318
        ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63319
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
63320
        HYBRID_BREAK();
63321
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CONST):
63322
        VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CONST)
63323
        ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63324
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CONST)
63325
        HYBRID_BREAK();
63326
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CONST):
63327
        VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CONST)
63328
        ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63329
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CONST)
63330
        HYBRID_BREAK();
63331
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST):
63332
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
63333
        ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63334
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
63335
        HYBRID_BREAK();
63336
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST):
63337
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
63338
        ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63339
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
63340
        HYBRID_BREAK();
63341
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CONST):
63342
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CONST)
63343
        ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63344
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CONST)
63345
        HYBRID_BREAK();
63346
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST):
63347
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
63348
        ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63349
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
63350
        HYBRID_BREAK();
63351
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CONST):
63352
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
63353
        ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63354
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
63355
        HYBRID_BREAK();
63356
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CONST):
63357
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
63358
        ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63359
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
63360
        HYBRID_BREAK();
63361
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CONST):
63362
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
63363
        ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63364
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
63365
        HYBRID_BREAK();
63366
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST):
63367
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
63368
        ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63369
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
63370
        HYBRID_BREAK();
63371
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST):
63372
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
63373
        ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63374
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
63375
        HYBRID_BREAK();
63376
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST):
63377
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
63378
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63379
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
63380
        HYBRID_BREAK();
63381
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST):
63382
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
63383
        ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63384
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
63385
        HYBRID_BREAK();
63386
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST):
63387
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
63388
        ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63389
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
63390
        HYBRID_BREAK();
63391
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST):
63392
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
63393
        ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63394
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
63395
        HYBRID_BREAK();
63396
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST):
63397
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
63398
        ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63399
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
63400
        HYBRID_BREAK();
63401
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST):
63402
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
63403
        ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63404
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
63405
        HYBRID_BREAK();
63406
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST):
63407
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
63408
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63409
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
63410
        HYBRID_BREAK();
63411
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST):
63412
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
63413
        ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63414
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
63415
        HYBRID_BREAK();
63416
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST):
63417
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
63418
        ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63419
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
63420
        HYBRID_BREAK();
63421
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP):
63422
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
63423
        ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63424
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
63425
        HYBRID_BREAK();
63426
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR):
63427
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
63428
        ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63429
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
63430
        HYBRID_BREAK();
63431
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV):
63432
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
63433
        ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63434
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
63435
        HYBRID_BREAK();
63436
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST):
63437
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
63438
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63439
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
63440
        HYBRID_BREAK();
63441
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP):
63442
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
63443
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63444
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
63445
        HYBRID_BREAK();
63446
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR):
63447
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
63448
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63449
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
63450
        HYBRID_BREAK();
63451
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV):
63452
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
63453
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63454
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
63455
        HYBRID_BREAK();
63456
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED):
63457
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
63458
        ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63459
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
63460
        HYBRID_BREAK();
63461
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED):
63462
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
63463
        ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63464
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
63465
        HYBRID_BREAK();
63466
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR):
63467
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
63468
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63469
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
63470
        HYBRID_BREAK();
63471
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV):
63472
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
63473
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63474
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
63475
        HYBRID_BREAK();
63476
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CONST):
63477
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CONST)
63478
        ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63479
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CONST)
63480
        HYBRID_BREAK();
63481
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST):
63482
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
63483
        ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63484
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
63485
        HYBRID_BREAK();
63486
      HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST):
63487
        VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST)
63488
        ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63489
        VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_CONST)
63490
        HYBRID_BREAK();
63491
      HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_CONST):
63492
        VM_TRACE(ZEND_SEND_REF_SPEC_CV_CONST)
63493
        ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63494
        VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_CONST)
63495
        HYBRID_BREAK();
63496
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_CONST):
63497
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
63498
        ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63499
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
63500
        HYBRID_BREAK();
63501
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST):
63502
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
63503
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63504
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
63505
        HYBRID_BREAK();
63506
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CONST):
63507
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CONST)
63508
        ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63509
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CONST)
63510
        HYBRID_BREAK();
63511
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CONST):
63512
        VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CONST)
63513
        ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63514
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CONST)
63515
        HYBRID_BREAK();
63516
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CONST):
63517
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CONST)
63518
        ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63519
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CONST)
63520
        HYBRID_BREAK();
63521
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST):
63522
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
63523
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63524
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
63525
        HYBRID_BREAK();
63526
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST):
63527
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
63528
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63529
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
63530
        HYBRID_BREAK();
63531
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST):
63532
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
63533
        ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63534
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
63535
        HYBRID_BREAK();
63536
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_CONST):
63537
        VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_CONST)
63538
        ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63539
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_CONST)
63540
        HYBRID_BREAK();
63541
      HYBRID_CASE(ZEND_YIELD_SPEC_CV_CONST):
63542
        VM_TRACE(ZEND_YIELD_SPEC_CV_CONST)
63543
        ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63544
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CONST)
63545
        HYBRID_BREAK();
63546
      HYBRID_CASE(ZEND_BIND_GLOBAL_SPEC_CV_CONST):
63547
        VM_TRACE(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
63548
        ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63549
        VM_TRACE_OP_END(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
63550
        HYBRID_BREAK();
63551
      HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CV_CONST):
63552
        VM_TRACE(ZEND_IN_ARRAY_SPEC_CV_CONST)
63553
        ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63554
        VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CV_CONST)
63555
        HYBRID_BREAK();
63556
      HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST):
63557
        VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63558
        ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63559
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63560
        HYBRID_BREAK();
63561
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST):
63562
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63563
        ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63564
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63565
        HYBRID_BREAK();
63566
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST):
63567
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
63568
        ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63569
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
63570
        HYBRID_BREAK();
63571
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV):
63572
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
63573
        ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63574
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
63575
        HYBRID_BREAK();
63576
      HYBRID_CASE(ZEND_DIV_SPEC_CV_TMPVAR):
63577
        VM_TRACE(ZEND_DIV_SPEC_CV_TMPVAR)
63578
        ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63579
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_TMPVAR)
63580
        HYBRID_BREAK();
63581
      HYBRID_CASE(ZEND_POW_SPEC_CV_TMPVAR):
63582
        VM_TRACE(ZEND_POW_SPEC_CV_TMPVAR)
63583
        ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63584
        VM_TRACE_OP_END(ZEND_POW_SPEC_CV_TMPVAR)
63585
        HYBRID_BREAK();
63586
      HYBRID_CASE(ZEND_CONCAT_SPEC_CV_TMPVAR):
63587
        VM_TRACE(ZEND_CONCAT_SPEC_CV_TMPVAR)
63588
        ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63589
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_TMPVAR)
63590
        HYBRID_BREAK();
63591
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR):
63592
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
63593
        ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63594
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
63595
        HYBRID_BREAK();
63596
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ):
63597
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63598
        ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63599
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63600
        HYBRID_BREAK();
63601
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
63602
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63603
        ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63604
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63605
        HYBRID_BREAK();
63606
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR):
63607
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
63608
        ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63609
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
63610
        HYBRID_BREAK();
63611
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ):
63612
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63613
        ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63614
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63615
        HYBRID_BREAK();
63616
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
63617
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63618
        ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63619
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63620
        HYBRID_BREAK();
63621
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMPVAR):
63622
        VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
63623
        ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63624
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
63625
        HYBRID_BREAK();
63626
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR):
63627
        VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
63628
        ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63629
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
63630
        HYBRID_BREAK();
63631
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR):
63632
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
63633
        ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63634
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
63635
        HYBRID_BREAK();
63636
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR):
63637
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
63638
        ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63639
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
63640
        HYBRID_BREAK();
63641
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR):
63642
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
63643
        ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63644
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
63645
        HYBRID_BREAK();
63646
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR):
63647
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
63648
        ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63649
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
63650
        HYBRID_BREAK();
63651
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR):
63652
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
63653
        ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63654
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
63655
        HYBRID_BREAK();
63656
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR):
63657
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
63658
        ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63659
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
63660
        HYBRID_BREAK();
63661
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR):
63662
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
63663
        ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63664
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
63665
        HYBRID_BREAK();
63666
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR):
63667
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
63668
        ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63669
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
63670
        HYBRID_BREAK();
63671
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR):
63672
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
63673
        ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63674
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
63675
        HYBRID_BREAK();
63676
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR):
63677
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
63678
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63679
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
63680
        HYBRID_BREAK();
63681
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR):
63682
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
63683
        ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63684
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
63685
        HYBRID_BREAK();
63686
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR):
63687
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
63688
        ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63689
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
63690
        HYBRID_BREAK();
63691
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR):
63692
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
63693
        ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63694
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
63695
        HYBRID_BREAK();
63696
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR):
63697
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
63698
        ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63699
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
63700
        HYBRID_BREAK();
63701
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR):
63702
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
63703
        ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63704
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
63705
        HYBRID_BREAK();
63706
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR):
63707
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
63708
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63709
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
63710
        HYBRID_BREAK();
63711
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR):
63712
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
63713
        ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63714
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
63715
        HYBRID_BREAK();
63716
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST):
63717
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
63718
        ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63719
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
63720
        HYBRID_BREAK();
63721
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP):
63722
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
63723
        ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63724
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
63725
        HYBRID_BREAK();
63726
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR):
63727
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
63728
        ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63729
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
63730
        HYBRID_BREAK();
63731
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV):
63732
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
63733
        ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63734
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
63735
        HYBRID_BREAK();
63736
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST):
63737
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
63738
        ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63739
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
63740
        HYBRID_BREAK();
63741
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP):
63742
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
63743
        ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63744
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
63745
        HYBRID_BREAK();
63746
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR):
63747
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
63748
        ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63749
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
63750
        HYBRID_BREAK();
63751
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV):
63752
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
63753
        ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63754
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
63755
        HYBRID_BREAK();
63756
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR):
63757
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
63758
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63759
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
63760
        HYBRID_BREAK();
63761
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV):
63762
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
63763
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63764
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
63765
        HYBRID_BREAK();
63766
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR):
63767
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
63768
        ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63769
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
63770
        HYBRID_BREAK();
63771
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR):
63772
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
63773
        ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63774
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
63775
        HYBRID_BREAK();
63776
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR):
63777
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
63778
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63779
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
63780
        HYBRID_BREAK();
63781
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR):
63782
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
63783
        ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63784
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
63785
        HYBRID_BREAK();
63786
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR):
63787
        VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
63788
        ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63789
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
63790
        HYBRID_BREAK();
63791
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR):
63792
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
63793
        ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63794
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
63795
        HYBRID_BREAK();
63796
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR):
63797
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
63798
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63799
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
63800
        HYBRID_BREAK();
63801
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR):
63802
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
63803
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63804
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
63805
        HYBRID_BREAK();
63806
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR):
63807
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
63808
        ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63809
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
63810
        HYBRID_BREAK();
63811
      HYBRID_CASE(ZEND_YIELD_SPEC_CV_TMPVAR):
63812
        VM_TRACE(ZEND_YIELD_SPEC_CV_TMPVAR)
63813
        ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63814
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMPVAR)
63815
        HYBRID_BREAK();
63816
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_TMP):
63817
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
63818
        ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63819
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
63820
        HYBRID_BREAK();
63821
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP):
63822
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
63823
        ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63824
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
63825
        HYBRID_BREAK();
63826
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED):
63827
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
63828
        ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63829
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
63830
        HYBRID_BREAK();
63831
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED):
63832
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
63833
        ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63834
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
63835
        HYBRID_BREAK();
63836
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_VAR):
63837
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
63838
        ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63839
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
63840
        HYBRID_BREAK();
63841
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR):
63842
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
63843
        ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63844
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
63845
        HYBRID_BREAK();
63846
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED):
63847
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
63848
        ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63849
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
63850
        HYBRID_BREAK();
63851
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED):
63852
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
63853
        ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63854
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
63855
        HYBRID_BREAK();
63856
      HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_VAR):
63857
        VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR)
63858
        ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63859
        VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_VAR)
63860
        HYBRID_BREAK();
63861
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_VAR):
63862
        VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_VAR)
63863
        ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63864
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_VAR)
63865
        HYBRID_BREAK();
63866
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED):
63867
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
63868
        ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63869
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
63870
        HYBRID_BREAK();
63871
      HYBRID_CASE(ZEND_FETCH_R_SPEC_CV_UNUSED):
63872
        VM_TRACE(ZEND_FETCH_R_SPEC_CV_UNUSED)
63873
        ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63874
        VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CV_UNUSED)
63875
        HYBRID_BREAK();
63876
      HYBRID_CASE(ZEND_FETCH_W_SPEC_CV_UNUSED):
63877
        VM_TRACE(ZEND_FETCH_W_SPEC_CV_UNUSED)
63878
        ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63879
        VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CV_UNUSED)
63880
        HYBRID_BREAK();
63881
      HYBRID_CASE(ZEND_FETCH_RW_SPEC_CV_UNUSED):
63882
        VM_TRACE(ZEND_FETCH_RW_SPEC_CV_UNUSED)
63883
        ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63884
        VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CV_UNUSED)
63885
        HYBRID_BREAK();
63886
      HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED):
63887
        VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
63888
        ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63889
        VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
63890
        HYBRID_BREAK();
63891
      HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED):
63892
        VM_TRACE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
63893
        ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63894
        VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
63895
        HYBRID_BREAK();
63896
      HYBRID_CASE(ZEND_FETCH_IS_SPEC_CV_UNUSED):
63897
        VM_TRACE(ZEND_FETCH_IS_SPEC_CV_UNUSED)
63898
        ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63899
        VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CV_UNUSED)
63900
        HYBRID_BREAK();
63901
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED):
63902
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
63903
        ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63904
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
63905
        HYBRID_BREAK();
63906
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED):
63907
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
63908
        ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63909
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
63910
        HYBRID_BREAK();
63911
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED):
63912
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
63913
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63914
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
63915
        HYBRID_BREAK();
63916
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST):
63917
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
63918
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63919
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
63920
        HYBRID_BREAK();
63921
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP):
63922
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
63923
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63924
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
63925
        HYBRID_BREAK();
63926
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR):
63927
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
63928
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63929
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
63930
        HYBRID_BREAK();
63931
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV):
63932
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
63933
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63934
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
63935
        HYBRID_BREAK();
63936
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED):
63937
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
63938
        ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63939
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
63940
        HYBRID_BREAK();
63941
      HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_UNUSED):
63942
        VM_TRACE(ZEND_SEND_VAR_SPEC_CV_UNUSED)
63943
        ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63944
        VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_UNUSED)
63945
        HYBRID_BREAK();
63946
      HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_UNUSED):
63947
        VM_TRACE(ZEND_SEND_REF_SPEC_CV_UNUSED)
63948
        ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63949
        VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_UNUSED)
63950
        HYBRID_BREAK();
63951
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED):
63952
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
63953
        ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63954
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
63955
        HYBRID_BREAK();
63956
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK):
63957
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
63958
        ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63959
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
63960
        HYBRID_BREAK();
63961
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED):
63962
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
63963
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63964
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
63965
        HYBRID_BREAK();
63966
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED):
63967
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
63968
        ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63969
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
63970
        HYBRID_BREAK();
63971
      HYBRID_CASE(ZEND_UNSET_CV_SPEC_CV_UNUSED):
63972
        VM_TRACE(ZEND_UNSET_CV_SPEC_CV_UNUSED)
63973
        ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63974
        VM_TRACE_OP_END(ZEND_UNSET_CV_SPEC_CV_UNUSED)
63975
        HYBRID_BREAK();
63976
      HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CV_UNUSED):
63977
        VM_TRACE(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
63978
        ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63979
        VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
63980
        HYBRID_BREAK();
63981
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET):
63982
        VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
63983
        ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63984
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
63985
        HYBRID_BREAK();
63986
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY):
63987
        VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
63988
        ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63989
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
63990
        HYBRID_BREAK();
63991
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED):
63992
        VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
63993
        ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63994
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
63995
        HYBRID_BREAK();
63996
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_UNUSED):
63997
        VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
63998
        ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63999
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
64000
        HYBRID_BREAK();
64001
      HYBRID_CASE(ZEND_YIELD_SPEC_CV_UNUSED):
64002
        VM_TRACE(ZEND_YIELD_SPEC_CV_UNUSED)
64003
        ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64004
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_UNUSED)
64005
        HYBRID_BREAK();
64006
      HYBRID_CASE(ZEND_CHECK_VAR_SPEC_CV_UNUSED):
64007
        VM_TRACE(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
64008
        ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64009
        VM_TRACE_OP_END(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
64010
        HYBRID_BREAK();
64011
      HYBRID_CASE(ZEND_MAKE_REF_SPEC_CV_UNUSED):
64012
        VM_TRACE(ZEND_MAKE_REF_SPEC_CV_UNUSED)
64013
        ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64014
        VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_CV_UNUSED)
64015
        HYBRID_BREAK();
64016
      HYBRID_CASE(ZEND_COUNT_SPEC_CV_UNUSED):
64017
        VM_TRACE(ZEND_COUNT_SPEC_CV_UNUSED)
64018
        ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64019
        VM_TRACE_OP_END(ZEND_COUNT_SPEC_CV_UNUSED)
64020
        HYBRID_BREAK();
64021
      HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED):
64022
        VM_TRACE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
64023
        ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64024
        VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
64025
        HYBRID_BREAK();
64026
      HYBRID_CASE(ZEND_GET_CLASS_SPEC_CV_UNUSED):
64027
        VM_TRACE(ZEND_GET_CLASS_SPEC_CV_UNUSED)
64028
        ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64029
        VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CV_UNUSED)
64030
        HYBRID_BREAK();
64031
      HYBRID_CASE(ZEND_GET_TYPE_SPEC_CV_UNUSED):
64032
        VM_TRACE(ZEND_GET_TYPE_SPEC_CV_UNUSED)
64033
        ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64034
        VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CV_UNUSED)
64035
        HYBRID_BREAK();
64036
      HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED):
64037
        VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
64038
        ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64039
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
64040
        HYBRID_BREAK();
64041
      HYBRID_CASE(ZEND_DIV_SPEC_CV_CV):
64042
        VM_TRACE(ZEND_DIV_SPEC_CV_CV)
64043
        ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64044
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CV)
64045
        HYBRID_BREAK();
64046
      HYBRID_CASE(ZEND_POW_SPEC_CV_CV):
64047
        VM_TRACE(ZEND_POW_SPEC_CV_CV)
64048
        ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64049
        VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CV)
64050
        HYBRID_BREAK();
64051
      HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CV):
64052
        VM_TRACE(ZEND_CONCAT_SPEC_CV_CV)
64053
        ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64054
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CV)
64055
        HYBRID_BREAK();
64056
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CV):
64057
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CV)
64058
        ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64059
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CV)
64060
        HYBRID_BREAK();
64061
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV):
64062
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
64063
        ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64064
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
64065
        HYBRID_BREAK();
64066
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV):
64067
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV)
64068
        ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64069
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV)
64070
        HYBRID_BREAK();
64071
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ):
64072
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
64073
        ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64074
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
64075
        HYBRID_BREAK();
64076
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ):
64077
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
64078
        ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64079
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
64080
        HYBRID_BREAK();
64081
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV):
64082
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
64083
        ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64084
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
64085
        HYBRID_BREAK();
64086
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ):
64087
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
64088
        ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64089
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
64090
        HYBRID_BREAK();
64091
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ):
64092
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
64093
        ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64094
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
64095
        HYBRID_BREAK();
64096
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CV):
64097
        VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CV)
64098
        ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64099
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CV)
64100
        HYBRID_BREAK();
64101
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CV):
64102
        VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CV)
64103
        ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64104
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CV)
64105
        HYBRID_BREAK();
64106
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV):
64107
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
64108
        ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64109
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
64110
        HYBRID_BREAK();
64111
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV):
64112
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
64113
        ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64114
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
64115
        HYBRID_BREAK();
64116
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CV):
64117
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CV)
64118
        ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64119
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CV)
64120
        HYBRID_BREAK();
64121
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CV):
64122
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
64123
        ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64124
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
64125
        HYBRID_BREAK();
64126
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CV):
64127
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CV)
64128
        ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64129
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CV)
64130
        HYBRID_BREAK();
64131
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CV):
64132
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CV)
64133
        ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64134
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CV)
64135
        HYBRID_BREAK();
64136
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CV):
64137
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CV)
64138
        ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64139
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CV)
64140
        HYBRID_BREAK();
64141
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CV):
64142
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
64143
        ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64144
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
64145
        HYBRID_BREAK();
64146
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CV):
64147
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
64148
        ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64149
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
64150
        HYBRID_BREAK();
64151
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV):
64152
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
64153
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64154
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
64155
        HYBRID_BREAK();
64156
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV):
64157
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
64158
        ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64159
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
64160
        HYBRID_BREAK();
64161
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CV):
64162
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
64163
        ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64164
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
64165
        HYBRID_BREAK();
64166
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CV):
64167
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
64168
        ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64169
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
64170
        HYBRID_BREAK();
64171
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV):
64172
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
64173
        ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64174
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
64175
        HYBRID_BREAK();
64176
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV):
64177
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
64178
        ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64179
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
64180
        HYBRID_BREAK();
64181
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV):
64182
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
64183
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64184
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
64185
        HYBRID_BREAK();
64186
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV):
64187
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
64188
        ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64189
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
64190
        HYBRID_BREAK();
64191
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST):
64192
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
64193
        ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64194
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
64195
        HYBRID_BREAK();
64196
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP):
64197
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
64198
        ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64199
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
64200
        HYBRID_BREAK();
64201
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR):
64202
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
64203
        ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64204
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
64205
        HYBRID_BREAK();
64206
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV):
64207
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
64208
        ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64209
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
64210
        HYBRID_BREAK();
64211
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST):
64212
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
64213
        ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64214
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
64215
        HYBRID_BREAK();
64216
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP):
64217
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
64218
        ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64219
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
64220
        HYBRID_BREAK();
64221
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR):
64222
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
64223
        ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64224
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
64225
        HYBRID_BREAK();
64226
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV):
64227
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
64228
        ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64229
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
64230
        HYBRID_BREAK();
64231
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED):
64232
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
64233
        ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64234
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
64235
        HYBRID_BREAK();
64236
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED):
64237
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
64238
        ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64239
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
64240
        HYBRID_BREAK();
64241
      HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_CV):
64242
        VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV)
64243
        ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64244
        VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_CV)
64245
        HYBRID_BREAK();
64246
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR):
64247
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
64248
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64249
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
64250
        HYBRID_BREAK();
64251
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV):
64252
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
64253
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64254
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
64255
        HYBRID_BREAK();
64256
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CV):
64257
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CV)
64258
        ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64259
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CV)
64260
        HYBRID_BREAK();
64261
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV):
64262
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
64263
        ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64264
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
64265
        HYBRID_BREAK();
64266
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV):
64267
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
64268
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64269
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
64270
        HYBRID_BREAK();
64271
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CV):
64272
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CV)
64273
        ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64274
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CV)
64275
        HYBRID_BREAK();
64276
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CV):
64277
        VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CV)
64278
        ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64279
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CV)
64280
        HYBRID_BREAK();
64281
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CV):
64282
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CV)
64283
        ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64284
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CV)
64285
        HYBRID_BREAK();
64286
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV):
64287
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
64288
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64289
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
64290
        HYBRID_BREAK();
64291
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV):
64292
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
64293
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64294
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
64295
        HYBRID_BREAK();
64296
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV):
64297
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
64298
        ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64299
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
64300
        HYBRID_BREAK();
64301
      HYBRID_CASE(ZEND_YIELD_SPEC_CV_CV):
64302
        VM_TRACE(ZEND_YIELD_SPEC_CV_CV)
64303
        ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64304
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CV)
64305
        HYBRID_BREAK();
64306
      HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV):
64307
        VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
64308
        ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64309
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
64310
        HYBRID_BREAK();
64311
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV):
64312
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
64313
        ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64314
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
64315
        HYBRID_BREAK();
64316
      HYBRID_CASE(HYBRID_HALT):
64317
#ifdef ZEND_VM_FP_GLOBAL_REG
64318
        execute_data = vm_stack_data.orig_execute_data;
64319
#endif
64320
#ifdef ZEND_VM_IP_GLOBAL_REG
64321
        opline = vm_stack_data.orig_opline;
64322
#endif
64323
        return;
64324
      HYBRID_DEFAULT:
64325
        VM_TRACE(ZEND_NULL)
64326
        ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64327
        VM_TRACE_OP_END(ZEND_NULL)
64328
        HYBRID_BREAK(); /* Never reached */
64329
#else /* ZEND_VM_KIND != ZEND_VM_KIND_HYBRID */
64330
#ifdef ZEND_VM_FP_GLOBAL_REG
64331
      execute_data = vm_stack_data.orig_execute_data;
64332
# ifdef ZEND_VM_IP_GLOBAL_REG
64333
      opline = vm_stack_data.orig_opline;
64334
# endif
64335
      return;
64336
#else
64337
111k
      opline = (const zend_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT);
64338
111k
      if (EXPECTED(opline != NULL)) {
64339
58.1k
        execute_data = EG(current_execute_data);
64340
58.1k
        ZEND_VM_LOOP_INTERRUPT_CHECK();
64341
58.1k
      } else {
64342
# ifdef ZEND_VM_IP_GLOBAL_REG
64343
        opline = vm_stack_data.orig_opline;
64344
# endif
64345
53.7k
        return;
64346
53.7k
      }
64347
111k
#endif
64348
111k
#endif /* ZEND_VM_KIND != ZEND_VM_KIND_HYBRID */
64349
111k
    }
64350
64351
3.76M
  }
64352
29.3k
  zend_error_noreturn(E_CORE_ERROR, "Arrived at end of main loop which shouldn't happen");
64353
83.1k
}
64354
#if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
64355
# pragma GCC pop_options
64356
#endif
64357
64358
ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
64359
83.6k
{
64360
83.6k
  zend_execute_data *execute_data;
64361
83.6k
  void *object_or_called_scope;
64362
83.6k
  uint32_t call_info;
64363
64364
83.6k
  if (EG(exception) != NULL) {
64365
0
    return;
64366
0
  }
64367
64368
83.6k
  object_or_called_scope = zend_get_this_object(EG(current_execute_data));
64369
83.6k
  if (EXPECTED(!object_or_called_scope)) {
64370
83.6k
    object_or_called_scope = zend_get_called_scope(EG(current_execute_data));
64371
83.6k
    call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE;
64372
83.6k
  } else {
64373
0
    call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE | ZEND_CALL_HAS_THIS;
64374
0
  }
64375
83.6k
  execute_data = zend_vm_stack_push_call_frame(call_info,
64376
83.6k
    (zend_function*)op_array, 0, object_or_called_scope);
64377
83.6k
  if (EG(current_execute_data)) {
64378
0
    execute_data->symbol_table = zend_rebuild_symbol_table();
64379
83.6k
  } else {
64380
83.6k
    execute_data->symbol_table = &EG(symbol_table);
64381
83.6k
  }
64382
83.6k
  EX(prev_execute_data) = EG(current_execute_data);
64383
83.6k
  i_init_code_execute_data(execute_data, op_array, return_value);
64384
83.6k
  ZEND_OBSERVER_FCALL_BEGIN(execute_data);
64385
83.6k
  zend_execute_ex(execute_data);
64386
  /* Observer end handlers are called from ZEND_RETURN */
64387
83.6k
  zend_vm_stack_free_call_frame(execute_data);
64388
83.6k
}
64389
64390
64391
void zend_vm_init(void)
64392
16
{
64393
16
  static const void * const labels[] = {
64394
16
    ZEND_NOP_SPEC_HANDLER,
64395
16
    ZEND_ADD_SPEC_CONST_CONST_HANDLER,
64396
16
    ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64397
16
    ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64398
16
    ZEND_NULL_HANDLER,
64399
16
    ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64400
16
    ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64401
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64402
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64403
16
    ZEND_NULL_HANDLER,
64404
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64405
16
    ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64406
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64407
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64408
16
    ZEND_NULL_HANDLER,
64409
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64410
16
    ZEND_NULL_HANDLER,
64411
16
    ZEND_NULL_HANDLER,
64412
16
    ZEND_NULL_HANDLER,
64413
16
    ZEND_NULL_HANDLER,
64414
16
    ZEND_NULL_HANDLER,
64415
16
    ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64416
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64417
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64418
16
    ZEND_NULL_HANDLER,
64419
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64420
16
    ZEND_SUB_SPEC_CONST_CONST_HANDLER,
64421
16
    ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64422
16
    ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64423
16
    ZEND_NULL_HANDLER,
64424
16
    ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64425
16
    ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64426
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64427
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64428
16
    ZEND_NULL_HANDLER,
64429
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64430
16
    ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64431
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64432
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64433
16
    ZEND_NULL_HANDLER,
64434
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64435
16
    ZEND_NULL_HANDLER,
64436
16
    ZEND_NULL_HANDLER,
64437
16
    ZEND_NULL_HANDLER,
64438
16
    ZEND_NULL_HANDLER,
64439
16
    ZEND_NULL_HANDLER,
64440
16
    ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64441
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64442
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64443
16
    ZEND_NULL_HANDLER,
64444
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64445
16
    ZEND_MUL_SPEC_CONST_CONST_HANDLER,
64446
16
    ZEND_NULL_HANDLER,
64447
16
    ZEND_NULL_HANDLER,
64448
16
    ZEND_NULL_HANDLER,
64449
16
    ZEND_NULL_HANDLER,
64450
16
    ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64451
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64452
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64453
16
    ZEND_NULL_HANDLER,
64454
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64455
16
    ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64456
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64457
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64458
16
    ZEND_NULL_HANDLER,
64459
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64460
16
    ZEND_NULL_HANDLER,
64461
16
    ZEND_NULL_HANDLER,
64462
16
    ZEND_NULL_HANDLER,
64463
16
    ZEND_NULL_HANDLER,
64464
16
    ZEND_NULL_HANDLER,
64465
16
    ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64466
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64467
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64468
16
    ZEND_NULL_HANDLER,
64469
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64470
16
    ZEND_DIV_SPEC_CONST_CONST_HANDLER,
64471
16
    ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
64472
16
    ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
64473
16
    ZEND_NULL_HANDLER,
64474
16
    ZEND_DIV_SPEC_CONST_CV_HANDLER,
64475
16
    ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
64476
16
    ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64477
16
    ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64478
16
    ZEND_NULL_HANDLER,
64479
16
    ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
64480
16
    ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
64481
16
    ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64482
16
    ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64483
16
    ZEND_NULL_HANDLER,
64484
16
    ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
64485
16
    ZEND_NULL_HANDLER,
64486
16
    ZEND_NULL_HANDLER,
64487
16
    ZEND_NULL_HANDLER,
64488
16
    ZEND_NULL_HANDLER,
64489
16
    ZEND_NULL_HANDLER,
64490
16
    ZEND_DIV_SPEC_CV_CONST_HANDLER,
64491
16
    ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
64492
16
    ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
64493
16
    ZEND_NULL_HANDLER,
64494
16
    ZEND_DIV_SPEC_CV_CV_HANDLER,
64495
16
    ZEND_MOD_SPEC_CONST_CONST_HANDLER,
64496
16
    ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64497
16
    ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64498
16
    ZEND_NULL_HANDLER,
64499
16
    ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64500
16
    ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64501
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64502
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64503
16
    ZEND_NULL_HANDLER,
64504
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64505
16
    ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64506
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64507
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64508
16
    ZEND_NULL_HANDLER,
64509
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64510
16
    ZEND_NULL_HANDLER,
64511
16
    ZEND_NULL_HANDLER,
64512
16
    ZEND_NULL_HANDLER,
64513
16
    ZEND_NULL_HANDLER,
64514
16
    ZEND_NULL_HANDLER,
64515
16
    ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64516
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64517
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64518
16
    ZEND_NULL_HANDLER,
64519
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64520
16
    ZEND_SL_SPEC_CONST_CONST_HANDLER,
64521
16
    ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64522
16
    ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64523
16
    ZEND_NULL_HANDLER,
64524
16
    ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64525
16
    ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64526
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64527
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64528
16
    ZEND_NULL_HANDLER,
64529
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64530
16
    ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64531
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64532
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64533
16
    ZEND_NULL_HANDLER,
64534
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64535
16
    ZEND_NULL_HANDLER,
64536
16
    ZEND_NULL_HANDLER,
64537
16
    ZEND_NULL_HANDLER,
64538
16
    ZEND_NULL_HANDLER,
64539
16
    ZEND_NULL_HANDLER,
64540
16
    ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64541
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64542
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64543
16
    ZEND_NULL_HANDLER,
64544
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64545
16
    ZEND_SR_SPEC_CONST_CONST_HANDLER,
64546
16
    ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64547
16
    ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64548
16
    ZEND_NULL_HANDLER,
64549
16
    ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64550
16
    ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64551
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64552
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64553
16
    ZEND_NULL_HANDLER,
64554
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64555
16
    ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64556
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64557
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64558
16
    ZEND_NULL_HANDLER,
64559
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64560
16
    ZEND_NULL_HANDLER,
64561
16
    ZEND_NULL_HANDLER,
64562
16
    ZEND_NULL_HANDLER,
64563
16
    ZEND_NULL_HANDLER,
64564
16
    ZEND_NULL_HANDLER,
64565
16
    ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64566
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64567
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64568
16
    ZEND_NULL_HANDLER,
64569
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64570
16
    ZEND_NULL_HANDLER,
64571
16
    ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64572
16
    ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64573
16
    ZEND_NULL_HANDLER,
64574
16
    ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
64575
16
    ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64576
16
    ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64577
16
    ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64578
16
    ZEND_NULL_HANDLER,
64579
16
    ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64580
16
    ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64581
16
    ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64582
16
    ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64583
16
    ZEND_NULL_HANDLER,
64584
16
    ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64585
16
    ZEND_NULL_HANDLER,
64586
16
    ZEND_NULL_HANDLER,
64587
16
    ZEND_NULL_HANDLER,
64588
16
    ZEND_NULL_HANDLER,
64589
16
    ZEND_NULL_HANDLER,
64590
16
    ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
64591
16
    ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64592
16
    ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64593
16
    ZEND_NULL_HANDLER,
64594
16
    ZEND_CONCAT_SPEC_CV_CV_HANDLER,
64595
16
    ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
64596
16
    ZEND_NULL_HANDLER,
64597
16
    ZEND_NULL_HANDLER,
64598
16
    ZEND_NULL_HANDLER,
64599
16
    ZEND_NULL_HANDLER,
64600
16
    ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64601
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64602
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64603
16
    ZEND_NULL_HANDLER,
64604
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64605
16
    ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64606
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64607
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64608
16
    ZEND_NULL_HANDLER,
64609
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64610
16
    ZEND_NULL_HANDLER,
64611
16
    ZEND_NULL_HANDLER,
64612
16
    ZEND_NULL_HANDLER,
64613
16
    ZEND_NULL_HANDLER,
64614
16
    ZEND_NULL_HANDLER,
64615
16
    ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64616
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64617
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64618
16
    ZEND_NULL_HANDLER,
64619
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64620
16
    ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
64621
16
    ZEND_NULL_HANDLER,
64622
16
    ZEND_NULL_HANDLER,
64623
16
    ZEND_NULL_HANDLER,
64624
16
    ZEND_NULL_HANDLER,
64625
16
    ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64626
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64627
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64628
16
    ZEND_NULL_HANDLER,
64629
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64630
16
    ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64631
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64632
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64633
16
    ZEND_NULL_HANDLER,
64634
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64635
16
    ZEND_NULL_HANDLER,
64636
16
    ZEND_NULL_HANDLER,
64637
16
    ZEND_NULL_HANDLER,
64638
16
    ZEND_NULL_HANDLER,
64639
16
    ZEND_NULL_HANDLER,
64640
16
    ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64641
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64642
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64643
16
    ZEND_NULL_HANDLER,
64644
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64645
16
    ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
64646
16
    ZEND_NULL_HANDLER,
64647
16
    ZEND_NULL_HANDLER,
64648
16
    ZEND_NULL_HANDLER,
64649
16
    ZEND_NULL_HANDLER,
64650
16
    ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64651
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64652
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64653
16
    ZEND_NULL_HANDLER,
64654
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64655
16
    ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64656
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64657
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64658
16
    ZEND_NULL_HANDLER,
64659
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64660
16
    ZEND_NULL_HANDLER,
64661
16
    ZEND_NULL_HANDLER,
64662
16
    ZEND_NULL_HANDLER,
64663
16
    ZEND_NULL_HANDLER,
64664
16
    ZEND_NULL_HANDLER,
64665
16
    ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64666
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64667
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64668
16
    ZEND_NULL_HANDLER,
64669
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64670
16
    ZEND_POW_SPEC_CONST_CONST_HANDLER,
64671
16
    ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
64672
16
    ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
64673
16
    ZEND_NULL_HANDLER,
64674
16
    ZEND_POW_SPEC_CONST_CV_HANDLER,
64675
16
    ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
64676
16
    ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64677
16
    ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64678
16
    ZEND_NULL_HANDLER,
64679
16
    ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
64680
16
    ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
64681
16
    ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64682
16
    ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64683
16
    ZEND_NULL_HANDLER,
64684
16
    ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
64685
16
    ZEND_NULL_HANDLER,
64686
16
    ZEND_NULL_HANDLER,
64687
16
    ZEND_NULL_HANDLER,
64688
16
    ZEND_NULL_HANDLER,
64689
16
    ZEND_NULL_HANDLER,
64690
16
    ZEND_POW_SPEC_CV_CONST_HANDLER,
64691
16
    ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
64692
16
    ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
64693
16
    ZEND_NULL_HANDLER,
64694
16
    ZEND_POW_SPEC_CV_CV_HANDLER,
64695
16
    ZEND_BW_NOT_SPEC_CONST_HANDLER,
64696
16
    ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64697
16
    ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64698
16
    ZEND_NULL_HANDLER,
64699
16
    ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64700
16
    ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
64701
16
    ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
64702
16
    ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
64703
16
    ZEND_NULL_HANDLER,
64704
16
    ZEND_BOOL_NOT_SPEC_CV_HANDLER,
64705
16
    ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
64706
16
    ZEND_NULL_HANDLER,
64707
16
    ZEND_NULL_HANDLER,
64708
16
    ZEND_NULL_HANDLER,
64709
16
    ZEND_NULL_HANDLER,
64710
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
64711
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64712
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64713
16
    ZEND_NULL_HANDLER,
64714
16
    ZEND_NULL_HANDLER,
64715
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
64716
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64717
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64718
16
    ZEND_NULL_HANDLER,
64719
16
    ZEND_NULL_HANDLER,
64720
16
    ZEND_NULL_HANDLER,
64721
16
    ZEND_NULL_HANDLER,
64722
16
    ZEND_NULL_HANDLER,
64723
16
    ZEND_NULL_HANDLER,
64724
16
    ZEND_NULL_HANDLER,
64725
16
    ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
64726
16
    ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
64727
16
    ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
64728
16
    ZEND_NULL_HANDLER,
64729
16
    ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
64730
16
    ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
64731
16
    ZEND_NULL_HANDLER,
64732
16
    ZEND_NULL_HANDLER,
64733
16
    ZEND_NULL_HANDLER,
64734
16
    ZEND_NULL_HANDLER,
64735
16
    ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
64736
16
    ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
64737
16
    ZEND_NULL_HANDLER,
64738
16
    ZEND_NULL_HANDLER,
64739
16
    ZEND_NULL_HANDLER,
64740
16
    ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
64741
16
    ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
64742
16
    ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
64743
16
    ZEND_NULL_HANDLER,
64744
16
    ZEND_NULL_HANDLER,
64745
16
    ZEND_NULL_HANDLER,
64746
16
    ZEND_NULL_HANDLER,
64747
16
    ZEND_NULL_HANDLER,
64748
16
    ZEND_NULL_HANDLER,
64749
16
    ZEND_NULL_HANDLER,
64750
16
    ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
64751
16
    ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
64752
16
    ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
64753
16
    ZEND_NULL_HANDLER,
64754
16
    ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
64755
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
64756
16
    ZEND_NULL_HANDLER,
64757
16
    ZEND_NULL_HANDLER,
64758
16
    ZEND_NULL_HANDLER,
64759
16
    ZEND_NULL_HANDLER,
64760
16
    ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
64761
16
    ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
64762
16
    ZEND_NULL_HANDLER,
64763
16
    ZEND_NULL_HANDLER,
64764
16
    ZEND_NULL_HANDLER,
64765
16
    ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
64766
16
    ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
64767
16
    ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
64768
16
    ZEND_NULL_HANDLER,
64769
16
    ZEND_NULL_HANDLER,
64770
16
    ZEND_NULL_HANDLER,
64771
16
    ZEND_NULL_HANDLER,
64772
16
    ZEND_NULL_HANDLER,
64773
16
    ZEND_NULL_HANDLER,
64774
16
    ZEND_NULL_HANDLER,
64775
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
64776
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
64777
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
64778
16
    ZEND_NULL_HANDLER,
64779
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
64780
16
    ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64781
16
    ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64782
16
    ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64783
16
    ZEND_NULL_HANDLER,
64784
16
    ZEND_NULL_HANDLER,
64785
16
    ZEND_NULL_HANDLER,
64786
16
    ZEND_NULL_HANDLER,
64787
16
    ZEND_NULL_HANDLER,
64788
16
    ZEND_NULL_HANDLER,
64789
16
    ZEND_NULL_HANDLER,
64790
16
    ZEND_NULL_HANDLER,
64791
16
    ZEND_NULL_HANDLER,
64792
16
    ZEND_NULL_HANDLER,
64793
16
    ZEND_NULL_HANDLER,
64794
16
    ZEND_NULL_HANDLER,
64795
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64796
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64797
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64798
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64799
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64800
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64801
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64802
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64803
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64804
16
    ZEND_NULL_HANDLER,
64805
16
    ZEND_NULL_HANDLER,
64806
16
    ZEND_NULL_HANDLER,
64807
16
    ZEND_NULL_HANDLER,
64808
16
    ZEND_NULL_HANDLER,
64809
16
    ZEND_NULL_HANDLER,
64810
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64811
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64812
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64813
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64814
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64815
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64816
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64817
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64818
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64819
16
    ZEND_NULL_HANDLER,
64820
16
    ZEND_NULL_HANDLER,
64821
16
    ZEND_NULL_HANDLER,
64822
16
    ZEND_NULL_HANDLER,
64823
16
    ZEND_NULL_HANDLER,
64824
16
    ZEND_NULL_HANDLER,
64825
16
    ZEND_NULL_HANDLER,
64826
16
    ZEND_NULL_HANDLER,
64827
16
    ZEND_NULL_HANDLER,
64828
16
    ZEND_NULL_HANDLER,
64829
16
    ZEND_NULL_HANDLER,
64830
16
    ZEND_NULL_HANDLER,
64831
16
    ZEND_NULL_HANDLER,
64832
16
    ZEND_NULL_HANDLER,
64833
16
    ZEND_NULL_HANDLER,
64834
16
    ZEND_NULL_HANDLER,
64835
16
    ZEND_NULL_HANDLER,
64836
16
    ZEND_NULL_HANDLER,
64837
16
    ZEND_NULL_HANDLER,
64838
16
    ZEND_NULL_HANDLER,
64839
16
    ZEND_NULL_HANDLER,
64840
16
    ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
64841
16
    ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
64842
16
    ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
64843
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64844
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64845
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64846
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64847
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64848
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64849
16
    ZEND_NULL_HANDLER,
64850
16
    ZEND_NULL_HANDLER,
64851
16
    ZEND_NULL_HANDLER,
64852
16
    ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
64853
16
    ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
64854
16
    ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
64855
16
    ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64856
16
    ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64857
16
    ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64858
16
    ZEND_NULL_HANDLER,
64859
16
    ZEND_NULL_HANDLER,
64860
16
    ZEND_NULL_HANDLER,
64861
16
    ZEND_NULL_HANDLER,
64862
16
    ZEND_NULL_HANDLER,
64863
16
    ZEND_NULL_HANDLER,
64864
16
    ZEND_NULL_HANDLER,
64865
16
    ZEND_NULL_HANDLER,
64866
16
    ZEND_NULL_HANDLER,
64867
16
    ZEND_NULL_HANDLER,
64868
16
    ZEND_NULL_HANDLER,
64869
16
    ZEND_NULL_HANDLER,
64870
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64871
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64872
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64873
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64874
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64875
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64876
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64877
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64878
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64879
16
    ZEND_NULL_HANDLER,
64880
16
    ZEND_NULL_HANDLER,
64881
16
    ZEND_NULL_HANDLER,
64882
16
    ZEND_NULL_HANDLER,
64883
16
    ZEND_NULL_HANDLER,
64884
16
    ZEND_NULL_HANDLER,
64885
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64886
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64887
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64888
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64889
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64890
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64891
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64892
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64893
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64894
16
    ZEND_NULL_HANDLER,
64895
16
    ZEND_NULL_HANDLER,
64896
16
    ZEND_NULL_HANDLER,
64897
16
    ZEND_NULL_HANDLER,
64898
16
    ZEND_NULL_HANDLER,
64899
16
    ZEND_NULL_HANDLER,
64900
16
    ZEND_NULL_HANDLER,
64901
16
    ZEND_NULL_HANDLER,
64902
16
    ZEND_NULL_HANDLER,
64903
16
    ZEND_NULL_HANDLER,
64904
16
    ZEND_NULL_HANDLER,
64905
16
    ZEND_NULL_HANDLER,
64906
16
    ZEND_NULL_HANDLER,
64907
16
    ZEND_NULL_HANDLER,
64908
16
    ZEND_NULL_HANDLER,
64909
16
    ZEND_NULL_HANDLER,
64910
16
    ZEND_NULL_HANDLER,
64911
16
    ZEND_NULL_HANDLER,
64912
16
    ZEND_NULL_HANDLER,
64913
16
    ZEND_NULL_HANDLER,
64914
16
    ZEND_NULL_HANDLER,
64915
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
64916
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
64917
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
64918
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64919
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64920
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64921
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64922
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64923
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64924
16
    ZEND_NULL_HANDLER,
64925
16
    ZEND_NULL_HANDLER,
64926
16
    ZEND_NULL_HANDLER,
64927
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
64928
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
64929
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
64930
16
    ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64931
16
    ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64932
16
    ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64933
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64934
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64935
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64936
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64937
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64938
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64939
16
    ZEND_NULL_HANDLER,
64940
16
    ZEND_NULL_HANDLER,
64941
16
    ZEND_NULL_HANDLER,
64942
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64943
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64944
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64945
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64946
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64947
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64948
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64949
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64950
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64951
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64952
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64953
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64954
16
    ZEND_NULL_HANDLER,
64955
16
    ZEND_NULL_HANDLER,
64956
16
    ZEND_NULL_HANDLER,
64957
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64958
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64959
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64960
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64961
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64962
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64963
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64964
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64965
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64966
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64967
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64968
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64969
16
    ZEND_NULL_HANDLER,
64970
16
    ZEND_NULL_HANDLER,
64971
16
    ZEND_NULL_HANDLER,
64972
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64973
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64974
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64975
16
    ZEND_NULL_HANDLER,
64976
16
    ZEND_NULL_HANDLER,
64977
16
    ZEND_NULL_HANDLER,
64978
16
    ZEND_NULL_HANDLER,
64979
16
    ZEND_NULL_HANDLER,
64980
16
    ZEND_NULL_HANDLER,
64981
16
    ZEND_NULL_HANDLER,
64982
16
    ZEND_NULL_HANDLER,
64983
16
    ZEND_NULL_HANDLER,
64984
16
    ZEND_NULL_HANDLER,
64985
16
    ZEND_NULL_HANDLER,
64986
16
    ZEND_NULL_HANDLER,
64987
16
    ZEND_NULL_HANDLER,
64988
16
    ZEND_NULL_HANDLER,
64989
16
    ZEND_NULL_HANDLER,
64990
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64991
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64992
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64993
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64994
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64995
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64996
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64997
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64998
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64999
16
    ZEND_NULL_HANDLER,
65000
16
    ZEND_NULL_HANDLER,
65001
16
    ZEND_NULL_HANDLER,
65002
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65003
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65004
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65005
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
65006
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
65007
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
65008
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
65009
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65010
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65011
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
65012
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65013
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65014
16
    ZEND_NULL_HANDLER,
65015
16
    ZEND_NULL_HANDLER,
65016
16
    ZEND_NULL_HANDLER,
65017
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
65018
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65019
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65020
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
65021
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65022
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65023
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65024
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65025
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65026
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65027
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65028
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65029
16
    ZEND_NULL_HANDLER,
65030
16
    ZEND_NULL_HANDLER,
65031
16
    ZEND_NULL_HANDLER,
65032
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65033
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65034
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65035
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
65036
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65037
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65038
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65039
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65040
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65041
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65042
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65043
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65044
16
    ZEND_NULL_HANDLER,
65045
16
    ZEND_NULL_HANDLER,
65046
16
    ZEND_NULL_HANDLER,
65047
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65048
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65049
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65050
16
    ZEND_NULL_HANDLER,
65051
16
    ZEND_NULL_HANDLER,
65052
16
    ZEND_NULL_HANDLER,
65053
16
    ZEND_NULL_HANDLER,
65054
16
    ZEND_NULL_HANDLER,
65055
16
    ZEND_NULL_HANDLER,
65056
16
    ZEND_NULL_HANDLER,
65057
16
    ZEND_NULL_HANDLER,
65058
16
    ZEND_NULL_HANDLER,
65059
16
    ZEND_NULL_HANDLER,
65060
16
    ZEND_NULL_HANDLER,
65061
16
    ZEND_NULL_HANDLER,
65062
16
    ZEND_NULL_HANDLER,
65063
16
    ZEND_NULL_HANDLER,
65064
16
    ZEND_NULL_HANDLER,
65065
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
65066
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65067
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65068
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65069
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65070
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65071
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65072
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65073
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65074
16
    ZEND_NULL_HANDLER,
65075
16
    ZEND_NULL_HANDLER,
65076
16
    ZEND_NULL_HANDLER,
65077
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65078
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65079
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65080
16
    ZEND_NULL_HANDLER,
65081
16
    ZEND_NULL_HANDLER,
65082
16
    ZEND_NULL_HANDLER,
65083
16
    ZEND_NULL_HANDLER,
65084
16
    ZEND_NULL_HANDLER,
65085
16
    ZEND_NULL_HANDLER,
65086
16
    ZEND_NULL_HANDLER,
65087
16
    ZEND_NULL_HANDLER,
65088
16
    ZEND_NULL_HANDLER,
65089
16
    ZEND_NULL_HANDLER,
65090
16
    ZEND_NULL_HANDLER,
65091
16
    ZEND_NULL_HANDLER,
65092
16
    ZEND_NULL_HANDLER,
65093
16
    ZEND_NULL_HANDLER,
65094
16
    ZEND_NULL_HANDLER,
65095
16
    ZEND_NULL_HANDLER,
65096
16
    ZEND_NULL_HANDLER,
65097
16
    ZEND_NULL_HANDLER,
65098
16
    ZEND_NULL_HANDLER,
65099
16
    ZEND_NULL_HANDLER,
65100
16
    ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER,
65101
16
    ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER,
65102
16
    ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER,
65103
16
    ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER,
65104
16
    ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER,
65105
16
    ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER,
65106
16
    ZEND_NULL_HANDLER,
65107
16
    ZEND_NULL_HANDLER,
65108
16
    ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
65109
16
    ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER,
65110
16
    ZEND_NULL_HANDLER,
65111
16
    ZEND_NULL_HANDLER,
65112
16
    ZEND_NULL_HANDLER,
65113
16
    ZEND_NULL_HANDLER,
65114
16
    ZEND_NULL_HANDLER,
65115
16
    ZEND_NULL_HANDLER,
65116
16
    ZEND_NULL_HANDLER,
65117
16
    ZEND_NULL_HANDLER,
65118
16
    ZEND_NULL_HANDLER,
65119
16
    ZEND_NULL_HANDLER,
65120
16
    ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER,
65121
16
    ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER,
65122
16
    ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER,
65123
16
    ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER,
65124
16
    ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER,
65125
16
    ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER,
65126
16
    ZEND_NULL_HANDLER,
65127
16
    ZEND_NULL_HANDLER,
65128
16
    ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER,
65129
16
    ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER,
65130
16
    ZEND_NULL_HANDLER,
65131
16
    ZEND_NULL_HANDLER,
65132
16
    ZEND_NULL_HANDLER,
65133
16
    ZEND_NULL_HANDLER,
65134
16
    ZEND_NULL_HANDLER,
65135
16
    ZEND_NULL_HANDLER,
65136
16
    ZEND_NULL_HANDLER,
65137
16
    ZEND_NULL_HANDLER,
65138
16
    ZEND_NULL_HANDLER,
65139
16
    ZEND_NULL_HANDLER,
65140
16
    ZEND_NULL_HANDLER,
65141
16
    ZEND_NULL_HANDLER,
65142
16
    ZEND_NULL_HANDLER,
65143
16
    ZEND_NULL_HANDLER,
65144
16
    ZEND_NULL_HANDLER,
65145
16
    ZEND_NULL_HANDLER,
65146
16
    ZEND_NULL_HANDLER,
65147
16
    ZEND_NULL_HANDLER,
65148
16
    ZEND_NULL_HANDLER,
65149
16
    ZEND_NULL_HANDLER,
65150
16
    ZEND_NULL_HANDLER,
65151
16
    ZEND_NULL_HANDLER,
65152
16
    ZEND_NULL_HANDLER,
65153
16
    ZEND_NULL_HANDLER,
65154
16
    ZEND_NULL_HANDLER,
65155
16
    ZEND_NULL_HANDLER,
65156
16
    ZEND_NULL_HANDLER,
65157
16
    ZEND_NULL_HANDLER,
65158
16
    ZEND_NULL_HANDLER,
65159
16
    ZEND_NULL_HANDLER,
65160
16
    ZEND_NULL_HANDLER,
65161
16
    ZEND_NULL_HANDLER,
65162
16
    ZEND_NULL_HANDLER,
65163
16
    ZEND_NULL_HANDLER,
65164
16
    ZEND_NULL_HANDLER,
65165
16
    ZEND_NULL_HANDLER,
65166
16
    ZEND_NULL_HANDLER,
65167
16
    ZEND_NULL_HANDLER,
65168
16
    ZEND_NULL_HANDLER,
65169
16
    ZEND_NULL_HANDLER,
65170
16
    ZEND_NULL_HANDLER,
65171
16
    ZEND_NULL_HANDLER,
65172
16
    ZEND_NULL_HANDLER,
65173
16
    ZEND_NULL_HANDLER,
65174
16
    ZEND_NULL_HANDLER,
65175
16
    ZEND_NULL_HANDLER,
65176
16
    ZEND_NULL_HANDLER,
65177
16
    ZEND_NULL_HANDLER,
65178
16
    ZEND_NULL_HANDLER,
65179
16
    ZEND_NULL_HANDLER,
65180
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
65181
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
65182
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65183
16
    ZEND_NULL_HANDLER,
65184
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65185
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65186
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65187
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65188
16
    ZEND_NULL_HANDLER,
65189
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65190
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65191
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65192
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65193
16
    ZEND_NULL_HANDLER,
65194
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65195
16
    ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER,
65196
16
    ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER,
65197
16
    ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER,
65198
16
    ZEND_NULL_HANDLER,
65199
16
    ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER,
65200
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
65201
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
65202
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65203
16
    ZEND_NULL_HANDLER,
65204
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65205
16
    ZEND_NULL_HANDLER,
65206
16
    ZEND_NULL_HANDLER,
65207
16
    ZEND_NULL_HANDLER,
65208
16
    ZEND_NULL_HANDLER,
65209
16
    ZEND_NULL_HANDLER,
65210
16
    ZEND_NULL_HANDLER,
65211
16
    ZEND_NULL_HANDLER,
65212
16
    ZEND_NULL_HANDLER,
65213
16
    ZEND_NULL_HANDLER,
65214
16
    ZEND_NULL_HANDLER,
65215
16
    ZEND_NULL_HANDLER,
65216
16
    ZEND_NULL_HANDLER,
65217
16
    ZEND_NULL_HANDLER,
65218
16
    ZEND_NULL_HANDLER,
65219
16
    ZEND_NULL_HANDLER,
65220
16
    ZEND_NULL_HANDLER,
65221
16
    ZEND_NULL_HANDLER,
65222
16
    ZEND_NULL_HANDLER,
65223
16
    ZEND_NULL_HANDLER,
65224
16
    ZEND_NULL_HANDLER,
65225
16
    ZEND_NULL_HANDLER,
65226
16
    ZEND_NULL_HANDLER,
65227
16
    ZEND_NULL_HANDLER,
65228
16
    ZEND_NULL_HANDLER,
65229
16
    ZEND_NULL_HANDLER,
65230
16
    ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
65231
16
    ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
65232
16
    ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65233
16
    ZEND_NULL_HANDLER,
65234
16
    ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65235
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65236
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65237
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65238
16
    ZEND_NULL_HANDLER,
65239
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65240
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65241
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65242
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65243
16
    ZEND_NULL_HANDLER,
65244
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65245
16
    ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER,
65246
16
    ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER,
65247
16
    ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER,
65248
16
    ZEND_NULL_HANDLER,
65249
16
    ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER,
65250
16
    ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
65251
16
    ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
65252
16
    ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65253
16
    ZEND_NULL_HANDLER,
65254
16
    ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65255
16
    ZEND_NULL_HANDLER,
65256
16
    ZEND_NULL_HANDLER,
65257
16
    ZEND_NULL_HANDLER,
65258
16
    ZEND_NULL_HANDLER,
65259
16
    ZEND_NULL_HANDLER,
65260
16
    ZEND_NULL_HANDLER,
65261
16
    ZEND_NULL_HANDLER,
65262
16
    ZEND_NULL_HANDLER,
65263
16
    ZEND_NULL_HANDLER,
65264
16
    ZEND_NULL_HANDLER,
65265
16
    ZEND_NULL_HANDLER,
65266
16
    ZEND_NULL_HANDLER,
65267
16
    ZEND_NULL_HANDLER,
65268
16
    ZEND_NULL_HANDLER,
65269
16
    ZEND_NULL_HANDLER,
65270
16
    ZEND_NULL_HANDLER,
65271
16
    ZEND_NULL_HANDLER,
65272
16
    ZEND_NULL_HANDLER,
65273
16
    ZEND_NULL_HANDLER,
65274
16
    ZEND_NULL_HANDLER,
65275
16
    ZEND_NULL_HANDLER,
65276
16
    ZEND_NULL_HANDLER,
65277
16
    ZEND_NULL_HANDLER,
65278
16
    ZEND_NULL_HANDLER,
65279
16
    ZEND_NULL_HANDLER,
65280
16
    ZEND_NULL_HANDLER,
65281
16
    ZEND_NULL_HANDLER,
65282
16
    ZEND_NULL_HANDLER,
65283
16
    ZEND_NULL_HANDLER,
65284
16
    ZEND_NULL_HANDLER,
65285
16
    ZEND_NULL_HANDLER,
65286
16
    ZEND_NULL_HANDLER,
65287
16
    ZEND_NULL_HANDLER,
65288
16
    ZEND_NULL_HANDLER,
65289
16
    ZEND_NULL_HANDLER,
65290
16
    ZEND_NULL_HANDLER,
65291
16
    ZEND_NULL_HANDLER,
65292
16
    ZEND_NULL_HANDLER,
65293
16
    ZEND_NULL_HANDLER,
65294
16
    ZEND_NULL_HANDLER,
65295
16
    ZEND_NULL_HANDLER,
65296
16
    ZEND_NULL_HANDLER,
65297
16
    ZEND_NULL_HANDLER,
65298
16
    ZEND_NULL_HANDLER,
65299
16
    ZEND_NULL_HANDLER,
65300
16
    ZEND_NULL_HANDLER,
65301
16
    ZEND_NULL_HANDLER,
65302
16
    ZEND_NULL_HANDLER,
65303
16
    ZEND_NULL_HANDLER,
65304
16
    ZEND_NULL_HANDLER,
65305
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
65306
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
65307
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65308
16
    ZEND_NULL_HANDLER,
65309
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65310
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65311
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65312
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65313
16
    ZEND_NULL_HANDLER,
65314
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65315
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65316
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65317
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65318
16
    ZEND_NULL_HANDLER,
65319
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65320
16
    ZEND_NULL_HANDLER,
65321
16
    ZEND_NULL_HANDLER,
65322
16
    ZEND_NULL_HANDLER,
65323
16
    ZEND_NULL_HANDLER,
65324
16
    ZEND_NULL_HANDLER,
65325
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
65326
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
65327
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65328
16
    ZEND_NULL_HANDLER,
65329
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65330
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER,
65331
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER,
65332
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
65333
16
    ZEND_NULL_HANDLER,
65334
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
65335
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
65336
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
65337
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65338
16
    ZEND_NULL_HANDLER,
65339
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65340
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
65341
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
65342
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65343
16
    ZEND_NULL_HANDLER,
65344
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65345
16
    ZEND_NULL_HANDLER,
65346
16
    ZEND_NULL_HANDLER,
65347
16
    ZEND_NULL_HANDLER,
65348
16
    ZEND_NULL_HANDLER,
65349
16
    ZEND_NULL_HANDLER,
65350
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER,
65351
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER,
65352
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
65353
16
    ZEND_NULL_HANDLER,
65354
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
65355
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
65356
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
65357
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65358
16
    ZEND_NULL_HANDLER,
65359
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65360
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65361
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65362
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65363
16
    ZEND_NULL_HANDLER,
65364
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65365
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65366
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65367
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65368
16
    ZEND_NULL_HANDLER,
65369
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65370
16
    ZEND_NULL_HANDLER,
65371
16
    ZEND_NULL_HANDLER,
65372
16
    ZEND_NULL_HANDLER,
65373
16
    ZEND_NULL_HANDLER,
65374
16
    ZEND_NULL_HANDLER,
65375
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
65376
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
65377
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65378
16
    ZEND_NULL_HANDLER,
65379
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65380
16
    ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER,
65381
16
    ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER,
65382
16
    ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER,
65383
16
    ZEND_NULL_HANDLER,
65384
16
    ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER,
65385
16
    ZEND_NULL_HANDLER,
65386
16
    ZEND_NULL_HANDLER,
65387
16
    ZEND_NULL_HANDLER,
65388
16
    ZEND_NULL_HANDLER,
65389
16
    ZEND_NULL_HANDLER,
65390
16
    ZEND_NULL_HANDLER,
65391
16
    ZEND_NULL_HANDLER,
65392
16
    ZEND_NULL_HANDLER,
65393
16
    ZEND_NULL_HANDLER,
65394
16
    ZEND_NULL_HANDLER,
65395
16
    ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER,
65396
16
    ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
65397
16
    ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
65398
16
    ZEND_NULL_HANDLER,
65399
16
    ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER,
65400
16
    ZEND_NULL_HANDLER,
65401
16
    ZEND_NULL_HANDLER,
65402
16
    ZEND_NULL_HANDLER,
65403
16
    ZEND_NULL_HANDLER,
65404
16
    ZEND_NULL_HANDLER,
65405
16
    ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER,
65406
16
    ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
65407
16
    ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
65408
16
    ZEND_NULL_HANDLER,
65409
16
    ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER,
65410
16
    ZEND_NULL_HANDLER,
65411
16
    ZEND_NULL_HANDLER,
65412
16
    ZEND_NULL_HANDLER,
65413
16
    ZEND_NULL_HANDLER,
65414
16
    ZEND_NULL_HANDLER,
65415
16
    ZEND_NULL_HANDLER,
65416
16
    ZEND_NULL_HANDLER,
65417
16
    ZEND_NULL_HANDLER,
65418
16
    ZEND_NULL_HANDLER,
65419
16
    ZEND_NULL_HANDLER,
65420
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER,
65421
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
65422
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
65423
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER,
65424
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER,
65425
16
    ZEND_NULL_HANDLER,
65426
16
    ZEND_NULL_HANDLER,
65427
16
    ZEND_NULL_HANDLER,
65428
16
    ZEND_NULL_HANDLER,
65429
16
    ZEND_NULL_HANDLER,
65430
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER,
65431
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
65432
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
65433
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER,
65434
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER,
65435
16
    ZEND_NULL_HANDLER,
65436
16
    ZEND_NULL_HANDLER,
65437
16
    ZEND_NULL_HANDLER,
65438
16
    ZEND_NULL_HANDLER,
65439
16
    ZEND_NULL_HANDLER,
65440
16
    ZEND_NULL_HANDLER,
65441
16
    ZEND_NULL_HANDLER,
65442
16
    ZEND_NULL_HANDLER,
65443
16
    ZEND_NULL_HANDLER,
65444
16
    ZEND_NULL_HANDLER,
65445
16
    ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER,
65446
16
    ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
65447
16
    ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
65448
16
    ZEND_NULL_HANDLER,
65449
16
    ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER,
65450
16
    ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER,
65451
16
    ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
65452
16
    ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
65453
16
    ZEND_NULL_HANDLER,
65454
16
    ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER,
65455
16
    ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER,
65456
16
    ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
65457
16
    ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
65458
16
    ZEND_NULL_HANDLER,
65459
16
    ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER,
65460
16
    ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER,
65461
16
    ZEND_NULL_HANDLER,
65462
16
    ZEND_NULL_HANDLER,
65463
16
    ZEND_NULL_HANDLER,
65464
16
    ZEND_NULL_HANDLER,
65465
16
    ZEND_NULL_HANDLER,
65466
16
    ZEND_NULL_HANDLER,
65467
16
    ZEND_NULL_HANDLER,
65468
16
    ZEND_NULL_HANDLER,
65469
16
    ZEND_NULL_HANDLER,
65470
16
    ZEND_NULL_HANDLER,
65471
16
    ZEND_NULL_HANDLER,
65472
16
    ZEND_NULL_HANDLER,
65473
16
    ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
65474
16
    ZEND_NULL_HANDLER,
65475
16
    ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
65476
16
    ZEND_NULL_HANDLER,
65477
16
    ZEND_NULL_HANDLER,
65478
16
    ZEND_NULL_HANDLER,
65479
16
    ZEND_NULL_HANDLER,
65480
16
    ZEND_NULL_HANDLER,
65481
16
    ZEND_NULL_HANDLER,
65482
16
    ZEND_NULL_HANDLER,
65483
16
    ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
65484
16
    ZEND_NULL_HANDLER,
65485
16
    ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
65486
16
    ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
65487
16
    ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
65488
16
    ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
65489
16
    ZEND_NULL_HANDLER,
65490
16
    ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
65491
16
    ZEND_NULL_HANDLER,
65492
16
    ZEND_NULL_HANDLER,
65493
16
    ZEND_NULL_HANDLER,
65494
16
    ZEND_NULL_HANDLER,
65495
16
    ZEND_NULL_HANDLER,
65496
16
    ZEND_NULL_HANDLER,
65497
16
    ZEND_NULL_HANDLER,
65498
16
    ZEND_NULL_HANDLER,
65499
16
    ZEND_NULL_HANDLER,
65500
16
    ZEND_NULL_HANDLER,
65501
16
    ZEND_NULL_HANDLER,
65502
16
    ZEND_NULL_HANDLER,
65503
16
    ZEND_NULL_HANDLER,
65504
16
    ZEND_NULL_HANDLER,
65505
16
    ZEND_NULL_HANDLER,
65506
16
    ZEND_NULL_HANDLER,
65507
16
    ZEND_NULL_HANDLER,
65508
16
    ZEND_NULL_HANDLER,
65509
16
    ZEND_NULL_HANDLER,
65510
16
    ZEND_NULL_HANDLER,
65511
16
    ZEND_NULL_HANDLER,
65512
16
    ZEND_NULL_HANDLER,
65513
16
    ZEND_NULL_HANDLER,
65514
16
    ZEND_NULL_HANDLER,
65515
16
    ZEND_NULL_HANDLER,
65516
16
    ZEND_NULL_HANDLER,
65517
16
    ZEND_NULL_HANDLER,
65518
16
    ZEND_NULL_HANDLER,
65519
16
    ZEND_NULL_HANDLER,
65520
16
    ZEND_NULL_HANDLER,
65521
16
    ZEND_NULL_HANDLER,
65522
16
    ZEND_NULL_HANDLER,
65523
16
    ZEND_NULL_HANDLER,
65524
16
    ZEND_NULL_HANDLER,
65525
16
    ZEND_NULL_HANDLER,
65526
16
    ZEND_NULL_HANDLER,
65527
16
    ZEND_NULL_HANDLER,
65528
16
    ZEND_NULL_HANDLER,
65529
16
    ZEND_NULL_HANDLER,
65530
16
    ZEND_NULL_HANDLER,
65531
16
    ZEND_NULL_HANDLER,
65532
16
    ZEND_NULL_HANDLER,
65533
16
    ZEND_NULL_HANDLER,
65534
16
    ZEND_NULL_HANDLER,
65535
16
    ZEND_NULL_HANDLER,
65536
16
    ZEND_NULL_HANDLER,
65537
16
    ZEND_NULL_HANDLER,
65538
16
    ZEND_NULL_HANDLER,
65539
16
    ZEND_NULL_HANDLER,
65540
16
    ZEND_NULL_HANDLER,
65541
16
    ZEND_NULL_HANDLER,
65542
16
    ZEND_NULL_HANDLER,
65543
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65544
16
    ZEND_NULL_HANDLER,
65545
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65546
16
    ZEND_NULL_HANDLER,
65547
16
    ZEND_NULL_HANDLER,
65548
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65549
16
    ZEND_NULL_HANDLER,
65550
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65551
16
    ZEND_NULL_HANDLER,
65552
16
    ZEND_NULL_HANDLER,
65553
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65554
16
    ZEND_NULL_HANDLER,
65555
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65556
16
    ZEND_NULL_HANDLER,
65557
16
    ZEND_NULL_HANDLER,
65558
16
    ZEND_NULL_HANDLER,
65559
16
    ZEND_NULL_HANDLER,
65560
16
    ZEND_NULL_HANDLER,
65561
16
    ZEND_NULL_HANDLER,
65562
16
    ZEND_NULL_HANDLER,
65563
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65564
16
    ZEND_NULL_HANDLER,
65565
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65566
16
    ZEND_NULL_HANDLER,
65567
16
    ZEND_NULL_HANDLER,
65568
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
65569
16
    ZEND_NULL_HANDLER,
65570
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
65571
16
    ZEND_NULL_HANDLER,
65572
16
    ZEND_NULL_HANDLER,
65573
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65574
16
    ZEND_NULL_HANDLER,
65575
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65576
16
    ZEND_NULL_HANDLER,
65577
16
    ZEND_NULL_HANDLER,
65578
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65579
16
    ZEND_NULL_HANDLER,
65580
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65581
16
    ZEND_NULL_HANDLER,
65582
16
    ZEND_NULL_HANDLER,
65583
16
    ZEND_NULL_HANDLER,
65584
16
    ZEND_NULL_HANDLER,
65585
16
    ZEND_NULL_HANDLER,
65586
16
    ZEND_NULL_HANDLER,
65587
16
    ZEND_NULL_HANDLER,
65588
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
65589
16
    ZEND_NULL_HANDLER,
65590
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
65591
16
    ZEND_NULL_HANDLER,
65592
16
    ZEND_NULL_HANDLER,
65593
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65594
16
    ZEND_NULL_HANDLER,
65595
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65596
16
    ZEND_NULL_HANDLER,
65597
16
    ZEND_NULL_HANDLER,
65598
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65599
16
    ZEND_NULL_HANDLER,
65600
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65601
16
    ZEND_NULL_HANDLER,
65602
16
    ZEND_NULL_HANDLER,
65603
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65604
16
    ZEND_NULL_HANDLER,
65605
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65606
16
    ZEND_NULL_HANDLER,
65607
16
    ZEND_NULL_HANDLER,
65608
16
    ZEND_NULL_HANDLER,
65609
16
    ZEND_NULL_HANDLER,
65610
16
    ZEND_NULL_HANDLER,
65611
16
    ZEND_NULL_HANDLER,
65612
16
    ZEND_NULL_HANDLER,
65613
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65614
16
    ZEND_NULL_HANDLER,
65615
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65616
16
    ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER,
65617
16
    ZEND_NULL_HANDLER,
65618
16
    ZEND_NULL_HANDLER,
65619
16
    ZEND_NULL_HANDLER,
65620
16
    ZEND_NULL_HANDLER,
65621
16
    ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
65622
16
    ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER,
65623
16
    ZEND_NULL_HANDLER,
65624
16
    ZEND_NULL_HANDLER,
65625
16
    ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER,
65626
16
    ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER,
65627
16
    ZEND_NULL_HANDLER,
65628
16
    ZEND_NULL_HANDLER,
65629
16
    ZEND_NULL_HANDLER,
65630
16
    ZEND_NULL_HANDLER,
65631
16
    ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
65632
16
    ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER,
65633
16
    ZEND_NULL_HANDLER,
65634
16
    ZEND_NULL_HANDLER,
65635
16
    ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER,
65636
16
    ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER,
65637
16
    ZEND_NULL_HANDLER,
65638
16
    ZEND_NULL_HANDLER,
65639
16
    ZEND_POST_INC_SPEC_VAR_HANDLER,
65640
16
    ZEND_NULL_HANDLER,
65641
16
    ZEND_POST_INC_SPEC_CV_HANDLER,
65642
16
    ZEND_NULL_HANDLER,
65643
16
    ZEND_NULL_HANDLER,
65644
16
    ZEND_POST_DEC_SPEC_VAR_HANDLER,
65645
16
    ZEND_NULL_HANDLER,
65646
16
    ZEND_POST_DEC_SPEC_CV_HANDLER,
65647
16
    ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER,
65648
16
    ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER,
65649
16
    ZEND_JMP_SPEC_HANDLER,
65650
16
    ZEND_JMPZ_SPEC_CONST_HANDLER,
65651
16
    ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
65652
16
    ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
65653
16
    ZEND_NULL_HANDLER,
65654
16
    ZEND_JMPZ_SPEC_CV_HANDLER,
65655
16
    ZEND_JMPNZ_SPEC_CONST_HANDLER,
65656
16
    ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
65657
16
    ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
65658
16
    ZEND_NULL_HANDLER,
65659
16
    ZEND_JMPNZ_SPEC_CV_HANDLER,
65660
16
    ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
65661
16
    ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
65662
16
    ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
65663
16
    ZEND_NULL_HANDLER,
65664
16
    ZEND_JMPZ_EX_SPEC_CV_HANDLER,
65665
16
    ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
65666
16
    ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
65667
16
    ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
65668
16
    ZEND_NULL_HANDLER,
65669
16
    ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
65670
16
    ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER,
65671
16
    ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
65672
16
    ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
65673
16
    ZEND_NULL_HANDLER,
65674
16
    ZEND_CASE_SPEC_TMPVAR_CV_HANDLER,
65675
16
    ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER,
65676
16
    ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
65677
16
    ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
65678
16
    ZEND_NULL_HANDLER,
65679
16
    ZEND_NULL_HANDLER,
65680
16
    ZEND_NULL_HANDLER,
65681
16
    ZEND_NULL_HANDLER,
65682
16
    ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER,
65683
16
    ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
65684
16
    ZEND_NULL_HANDLER,
65685
16
    ZEND_NULL_HANDLER,
65686
16
    ZEND_CAST_SPEC_CONST_HANDLER,
65687
16
    ZEND_CAST_SPEC_TMP_HANDLER,
65688
16
    ZEND_CAST_SPEC_VAR_HANDLER,
65689
16
    ZEND_NULL_HANDLER,
65690
16
    ZEND_CAST_SPEC_CV_HANDLER,
65691
16
    ZEND_BOOL_SPEC_CONST_HANDLER,
65692
16
    ZEND_BOOL_SPEC_TMPVAR_HANDLER,
65693
16
    ZEND_BOOL_SPEC_TMPVAR_HANDLER,
65694
16
    ZEND_NULL_HANDLER,
65695
16
    ZEND_BOOL_SPEC_CV_HANDLER,
65696
16
    ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER,
65697
16
    ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
65698
16
    ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
65699
16
    ZEND_NULL_HANDLER,
65700
16
    ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER,
65701
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
65702
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65703
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65704
16
    ZEND_NULL_HANDLER,
65705
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
65706
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
65707
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65708
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65709
16
    ZEND_NULL_HANDLER,
65710
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
65711
16
    ZEND_NULL_HANDLER,
65712
16
    ZEND_NULL_HANDLER,
65713
16
    ZEND_NULL_HANDLER,
65714
16
    ZEND_NULL_HANDLER,
65715
16
    ZEND_NULL_HANDLER,
65716
16
    ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER,
65717
16
    ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
65718
16
    ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
65719
16
    ZEND_NULL_HANDLER,
65720
16
    ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER,
65721
16
    ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER,
65722
16
    ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
65723
16
    ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
65724
16
    ZEND_NULL_HANDLER,
65725
16
    ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER,
65726
16
    ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER,
65727
16
    ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
65728
16
    ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
65729
16
    ZEND_NULL_HANDLER,
65730
16
    ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER,
65731
16
    ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER,
65732
16
    ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
65733
16
    ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
65734
16
    ZEND_NULL_HANDLER,
65735
16
    ZEND_ROPE_END_SPEC_TMP_CV_HANDLER,
65736
16
    ZEND_BEGIN_SILENCE_SPEC_HANDLER,
65737
16
    ZEND_END_SILENCE_SPEC_TMP_HANDLER,
65738
16
    ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
65739
16
    ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER,
65740
16
    ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER,
65741
16
    ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
65742
16
    ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
65743
16
    ZEND_INIT_FCALL_SPEC_CONST_HANDLER,
65744
16
    ZEND_RETURN_SPEC_CONST_HANDLER,
65745
16
    ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65746
16
    ZEND_RETURN_SPEC_TMP_HANDLER,
65747
16
    ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65748
16
    ZEND_RETURN_SPEC_VAR_HANDLER,
65749
16
    ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65750
16
    ZEND_NULL_HANDLER,
65751
16
    ZEND_NULL_HANDLER,
65752
16
    ZEND_RETURN_SPEC_CV_HANDLER,
65753
16
    ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65754
16
    ZEND_RECV_SPEC_UNUSED_HANDLER,
65755
16
    ZEND_RECV_INIT_SPEC_CONST_HANDLER,
65756
16
    ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER,
65757
16
    ZEND_NULL_HANDLER,
65758
16
    ZEND_NULL_HANDLER,
65759
16
    ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER,
65760
16
    ZEND_NULL_HANDLER,
65761
16
    ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
65762
16
    ZEND_NULL_HANDLER,
65763
16
    ZEND_NULL_HANDLER,
65764
16
    ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
65765
16
    ZEND_NULL_HANDLER,
65766
16
    ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
65767
16
    ZEND_NULL_HANDLER,
65768
16
    ZEND_NULL_HANDLER,
65769
16
    ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
65770
16
    ZEND_NULL_HANDLER,
65771
16
    ZEND_NULL_HANDLER,
65772
16
    ZEND_NULL_HANDLER,
65773
16
    ZEND_NULL_HANDLER,
65774
16
    ZEND_NULL_HANDLER,
65775
16
    ZEND_NULL_HANDLER,
65776
16
    ZEND_NULL_HANDLER,
65777
16
    ZEND_NULL_HANDLER,
65778
16
    ZEND_NULL_HANDLER,
65779
16
    ZEND_NULL_HANDLER,
65780
16
    ZEND_NULL_HANDLER,
65781
16
    ZEND_NULL_HANDLER,
65782
16
    ZEND_NULL_HANDLER,
65783
16
    ZEND_NULL_HANDLER,
65784
16
    ZEND_NULL_HANDLER,
65785
16
    ZEND_NULL_HANDLER,
65786
16
    ZEND_NULL_HANDLER,
65787
16
    ZEND_NULL_HANDLER,
65788
16
    ZEND_NULL_HANDLER,
65789
16
    ZEND_NULL_HANDLER,
65790
16
    ZEND_NULL_HANDLER,
65791
16
    ZEND_NULL_HANDLER,
65792
16
    ZEND_NULL_HANDLER,
65793
16
    ZEND_NULL_HANDLER,
65794
16
    ZEND_NULL_HANDLER,
65795
16
    ZEND_NULL_HANDLER,
65796
16
    ZEND_NULL_HANDLER,
65797
16
    ZEND_NULL_HANDLER,
65798
16
    ZEND_NULL_HANDLER,
65799
16
    ZEND_NULL_HANDLER,
65800
16
    ZEND_NULL_HANDLER,
65801
16
    ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
65802
16
    ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
65803
16
    ZEND_NULL_HANDLER,
65804
16
    ZEND_NULL_HANDLER,
65805
16
    ZEND_NULL_HANDLER,
65806
16
    ZEND_NULL_HANDLER,
65807
16
    ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER,
65808
16
    ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
65809
16
    ZEND_NULL_HANDLER,
65810
16
    ZEND_NULL_HANDLER,
65811
16
    ZEND_NULL_HANDLER,
65812
16
    ZEND_NULL_HANDLER,
65813
16
    ZEND_NULL_HANDLER,
65814
16
    ZEND_NULL_HANDLER,
65815
16
    ZEND_NULL_HANDLER,
65816
16
    ZEND_NULL_HANDLER,
65817
16
    ZEND_NULL_HANDLER,
65818
16
    ZEND_NULL_HANDLER,
65819
16
    ZEND_NULL_HANDLER,
65820
16
    ZEND_NULL_HANDLER,
65821
16
    ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
65822
16
    ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
65823
16
    ZEND_NULL_HANDLER,
65824
16
    ZEND_NULL_HANDLER,
65825
16
    ZEND_NULL_HANDLER,
65826
16
    ZEND_NULL_HANDLER,
65827
16
    ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER,
65828
16
    ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER,
65829
16
    ZEND_NULL_HANDLER,
65830
16
    ZEND_NULL_HANDLER,
65831
16
    ZEND_NULL_HANDLER,
65832
16
    ZEND_NULL_HANDLER,
65833
16
    ZEND_NULL_HANDLER,
65834
16
    ZEND_NULL_HANDLER,
65835
16
    ZEND_NULL_HANDLER,
65836
16
    ZEND_NULL_HANDLER,
65837
16
    ZEND_NULL_HANDLER,
65838
16
    ZEND_NULL_HANDLER,
65839
16
    ZEND_NULL_HANDLER,
65840
16
    ZEND_NULL_HANDLER,
65841
16
    ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER,
65842
16
    ZEND_NULL_HANDLER,
65843
16
    ZEND_NULL_HANDLER,
65844
16
    ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER,
65845
16
    ZEND_NULL_HANDLER,
65846
16
    ZEND_NULL_HANDLER,
65847
16
    ZEND_NULL_HANDLER,
65848
16
    ZEND_NULL_HANDLER,
65849
16
    ZEND_NULL_HANDLER,
65850
16
    ZEND_NULL_HANDLER,
65851
16
    ZEND_SEND_REF_SPEC_CV_CONST_HANDLER,
65852
16
    ZEND_NULL_HANDLER,
65853
16
    ZEND_NULL_HANDLER,
65854
16
    ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER,
65855
16
    ZEND_NULL_HANDLER,
65856
16
    ZEND_NEW_SPEC_CONST_UNUSED_HANDLER,
65857
16
    ZEND_NULL_HANDLER,
65858
16
    ZEND_NEW_SPEC_VAR_UNUSED_HANDLER,
65859
16
    ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER,
65860
16
    ZEND_NULL_HANDLER,
65861
16
    ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
65862
16
    ZEND_FREE_SPEC_TMPVAR_HANDLER,
65863
16
    ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
65864
16
    ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
65865
16
    ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
65866
16
    ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
65867
16
    ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
65868
16
    ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
65869
16
    ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
65870
16
    ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
65871
16
    ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
65872
16
    ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
65873
16
    ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
65874
16
    ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
65875
16
    ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
65876
16
    ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
65877
16
    ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
65878
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
65879
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
65880
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
65881
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
65882
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
65883
16
    ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
65884
16
    ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
65885
16
    ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
65886
16
    ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
65887
16
    ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
65888
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
65889
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
65890
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
65891
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
65892
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
65893
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
65894
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
65895
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
65896
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
65897
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
65898
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
65899
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
65900
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
65901
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
65902
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
65903
16
    ZEND_NULL_HANDLER,
65904
16
    ZEND_NULL_HANDLER,
65905
16
    ZEND_NULL_HANDLER,
65906
16
    ZEND_NULL_HANDLER,
65907
16
    ZEND_NULL_HANDLER,
65908
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
65909
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
65910
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
65911
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
65912
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
65913
16
    ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
65914
16
    ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65915
16
    ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
65916
16
    ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65917
16
    ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
65918
16
    ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65919
16
    ZEND_NULL_HANDLER,
65920
16
    ZEND_NULL_HANDLER,
65921
16
    ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
65922
16
    ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65923
16
    ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
65924
16
    ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
65925
16
    ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
65926
16
    ZEND_NULL_HANDLER,
65927
16
    ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
65928
16
    ZEND_NULL_HANDLER,
65929
16
    ZEND_NULL_HANDLER,
65930
16
    ZEND_NULL_HANDLER,
65931
16
    ZEND_NULL_HANDLER,
65932
16
    ZEND_NULL_HANDLER,
65933
16
    ZEND_NULL_HANDLER,
65934
16
    ZEND_NULL_HANDLER,
65935
16
    ZEND_NULL_HANDLER,
65936
16
    ZEND_NULL_HANDLER,
65937
16
    ZEND_NULL_HANDLER,
65938
16
    ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
65939
16
    ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
65940
16
    ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
65941
16
    ZEND_NULL_HANDLER,
65942
16
    ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
65943
16
    ZEND_NULL_HANDLER,
65944
16
    ZEND_NULL_HANDLER,
65945
16
    ZEND_NULL_HANDLER,
65946
16
    ZEND_NULL_HANDLER,
65947
16
    ZEND_NULL_HANDLER,
65948
16
    ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
65949
16
    ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
65950
16
    ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
65951
16
    ZEND_NULL_HANDLER,
65952
16
    ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
65953
16
    ZEND_NULL_HANDLER,
65954
16
    ZEND_NULL_HANDLER,
65955
16
    ZEND_NULL_HANDLER,
65956
16
    ZEND_NULL_HANDLER,
65957
16
    ZEND_NULL_HANDLER,
65958
16
    ZEND_NULL_HANDLER,
65959
16
    ZEND_NULL_HANDLER,
65960
16
    ZEND_NULL_HANDLER,
65961
16
    ZEND_NULL_HANDLER,
65962
16
    ZEND_NULL_HANDLER,
65963
16
    ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
65964
16
    ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65965
16
    ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65966
16
    ZEND_NULL_HANDLER,
65967
16
    ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
65968
16
    ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
65969
16
    ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65970
16
    ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65971
16
    ZEND_NULL_HANDLER,
65972
16
    ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
65973
16
    ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
65974
16
    ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
65975
16
    ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
65976
16
    ZEND_NULL_HANDLER,
65977
16
    ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
65978
16
    ZEND_FE_RESET_R_SPEC_CONST_HANDLER,
65979
16
    ZEND_FE_RESET_R_SPEC_TMP_HANDLER,
65980
16
    ZEND_FE_RESET_R_SPEC_VAR_HANDLER,
65981
16
    ZEND_NULL_HANDLER,
65982
16
    ZEND_FE_RESET_R_SPEC_CV_HANDLER,
65983
16
    ZEND_FE_FETCH_R_SPEC_VAR_HANDLER,
65984
16
    ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
65985
16
    ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
65986
16
    ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
65987
16
    ZEND_NULL_HANDLER,
65988
16
    ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
65989
16
    ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
65990
16
    ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
65991
16
    ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
65992
16
    ZEND_NULL_HANDLER,
65993
16
    ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
65994
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
65995
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65996
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65997
16
    ZEND_NULL_HANDLER,
65998
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
65999
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
66000
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66001
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66002
16
    ZEND_NULL_HANDLER,
66003
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
66004
16
    ZEND_NULL_HANDLER,
66005
16
    ZEND_NULL_HANDLER,
66006
16
    ZEND_NULL_HANDLER,
66007
16
    ZEND_NULL_HANDLER,
66008
16
    ZEND_NULL_HANDLER,
66009
16
    ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
66010
16
    ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
66011
16
    ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
66012
16
    ZEND_NULL_HANDLER,
66013
16
    ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
66014
16
    ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER,
66015
16
    ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
66016
16
    ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
66017
16
    ZEND_NULL_HANDLER,
66018
16
    ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER,
66019
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
66020
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66021
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66022
16
    ZEND_NULL_HANDLER,
66023
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
66024
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
66025
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66026
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66027
16
    ZEND_NULL_HANDLER,
66028
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
66029
16
    ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
66030
16
    ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
66031
16
    ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
66032
16
    ZEND_NULL_HANDLER,
66033
16
    ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
66034
16
    ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
66035
16
    ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
66036
16
    ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
66037
16
    ZEND_NULL_HANDLER,
66038
16
    ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
66039
16
    ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
66040
16
    ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
66041
16
    ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
66042
16
    ZEND_NULL_HANDLER,
66043
16
    ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
66044
16
    ZEND_NULL_HANDLER,
66045
16
    ZEND_NULL_HANDLER,
66046
16
    ZEND_NULL_HANDLER,
66047
16
    ZEND_NULL_HANDLER,
66048
16
    ZEND_NULL_HANDLER,
66049
16
    ZEND_NULL_HANDLER,
66050
16
    ZEND_NULL_HANDLER,
66051
16
    ZEND_NULL_HANDLER,
66052
16
    ZEND_NULL_HANDLER,
66053
16
    ZEND_NULL_HANDLER,
66054
16
    ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
66055
16
    ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
66056
16
    ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
66057
16
    ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
66058
16
    ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
66059
16
    ZEND_NULL_HANDLER,
66060
16
    ZEND_NULL_HANDLER,
66061
16
    ZEND_NULL_HANDLER,
66062
16
    ZEND_NULL_HANDLER,
66063
16
    ZEND_NULL_HANDLER,
66064
16
    ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
66065
16
    ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
66066
16
    ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
66067
16
    ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
66068
16
    ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
66069
16
    ZEND_NULL_HANDLER,
66070
16
    ZEND_NULL_HANDLER,
66071
16
    ZEND_NULL_HANDLER,
66072
16
    ZEND_NULL_HANDLER,
66073
16
    ZEND_NULL_HANDLER,
66074
16
    ZEND_NULL_HANDLER,
66075
16
    ZEND_NULL_HANDLER,
66076
16
    ZEND_NULL_HANDLER,
66077
16
    ZEND_NULL_HANDLER,
66078
16
    ZEND_NULL_HANDLER,
66079
16
    ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
66080
16
    ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
66081
16
    ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
66082
16
    ZEND_NULL_HANDLER,
66083
16
    ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
66084
16
    ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
66085
16
    ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
66086
16
    ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
66087
16
    ZEND_NULL_HANDLER,
66088
16
    ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
66089
16
    ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
66090
16
    ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
66091
16
    ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
66092
16
    ZEND_NULL_HANDLER,
66093
16
    ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
66094
16
    ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
66095
16
    ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
66096
16
    ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
66097
16
    ZEND_NULL_HANDLER,
66098
16
    ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
66099
16
    ZEND_NULL_HANDLER,
66100
16
    ZEND_NULL_HANDLER,
66101
16
    ZEND_NULL_HANDLER,
66102
16
    ZEND_NULL_HANDLER,
66103
16
    ZEND_NULL_HANDLER,
66104
16
    ZEND_NULL_HANDLER,
66105
16
    ZEND_NULL_HANDLER,
66106
16
    ZEND_NULL_HANDLER,
66107
16
    ZEND_NULL_HANDLER,
66108
16
    ZEND_NULL_HANDLER,
66109
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
66110
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
66111
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
66112
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
66113
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
66114
16
    ZEND_NULL_HANDLER,
66115
16
    ZEND_NULL_HANDLER,
66116
16
    ZEND_NULL_HANDLER,
66117
16
    ZEND_NULL_HANDLER,
66118
16
    ZEND_NULL_HANDLER,
66119
16
    ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
66120
16
    ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
66121
16
    ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
66122
16
    ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
66123
16
    ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
66124
16
    ZEND_NULL_HANDLER,
66125
16
    ZEND_NULL_HANDLER,
66126
16
    ZEND_NULL_HANDLER,
66127
16
    ZEND_NULL_HANDLER,
66128
16
    ZEND_NULL_HANDLER,
66129
16
    ZEND_NULL_HANDLER,
66130
16
    ZEND_NULL_HANDLER,
66131
16
    ZEND_NULL_HANDLER,
66132
16
    ZEND_NULL_HANDLER,
66133
16
    ZEND_NULL_HANDLER,
66134
16
    ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
66135
16
    ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
66136
16
    ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
66137
16
    ZEND_NULL_HANDLER,
66138
16
    ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
66139
16
    ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
66140
16
    ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
66141
16
    ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
66142
16
    ZEND_NULL_HANDLER,
66143
16
    ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
66144
16
    ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
66145
16
    ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
66146
16
    ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
66147
16
    ZEND_NULL_HANDLER,
66148
16
    ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
66149
16
    ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
66150
16
    ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
66151
16
    ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
66152
16
    ZEND_NULL_HANDLER,
66153
16
    ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
66154
16
    ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER,
66155
16
    ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
66156
16
    ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
66157
16
    ZEND_NULL_HANDLER,
66158
16
    ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER,
66159
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
66160
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66161
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66162
16
    ZEND_NULL_HANDLER,
66163
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
66164
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
66165
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66166
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66167
16
    ZEND_NULL_HANDLER,
66168
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
66169
16
    ZEND_NULL_HANDLER,
66170
16
    ZEND_NULL_HANDLER,
66171
16
    ZEND_NULL_HANDLER,
66172
16
    ZEND_NULL_HANDLER,
66173
16
    ZEND_NULL_HANDLER,
66174
16
    ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
66175
16
    ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
66176
16
    ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
66177
16
    ZEND_NULL_HANDLER,
66178
16
    ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
66179
16
    ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER,
66180
16
    ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
66181
16
    ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
66182
16
    ZEND_NULL_HANDLER,
66183
16
    ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER,
66184
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
66185
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66186
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66187
16
    ZEND_NULL_HANDLER,
66188
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
66189
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
66190
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66191
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66192
16
    ZEND_NULL_HANDLER,
66193
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
66194
16
    ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
66195
16
    ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
66196
16
    ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
66197
16
    ZEND_NULL_HANDLER,
66198
16
    ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
66199
16
    ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
66200
16
    ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
66201
16
    ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
66202
16
    ZEND_NULL_HANDLER,
66203
16
    ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
66204
16
    ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
66205
16
    ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
66206
16
    ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
66207
16
    ZEND_NULL_HANDLER,
66208
16
    ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
66209
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
66210
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66211
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66212
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
66213
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER,
66214
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
66215
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66216
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66217
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
66218
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER,
66219
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66220
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66221
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66222
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
66223
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
66224
16
    ZEND_NULL_HANDLER,
66225
16
    ZEND_NULL_HANDLER,
66226
16
    ZEND_NULL_HANDLER,
66227
16
    ZEND_NULL_HANDLER,
66228
16
    ZEND_NULL_HANDLER,
66229
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
66230
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66231
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66232
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
66233
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
66234
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
66235
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66236
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66237
16
    ZEND_NULL_HANDLER,
66238
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER,
66239
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
66240
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66241
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66242
16
    ZEND_NULL_HANDLER,
66243
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER,
66244
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66245
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66246
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66247
16
    ZEND_NULL_HANDLER,
66248
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
66249
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66250
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
66251
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
66252
16
    ZEND_NULL_HANDLER,
66253
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
66254
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
66255
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66256
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66257
16
    ZEND_NULL_HANDLER,
66258
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
66259
16
    ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
66260
16
    ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
66261
16
    ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
66262
16
    ZEND_NULL_HANDLER,
66263
16
    ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
66264
16
    ZEND_NULL_HANDLER,
66265
16
    ZEND_NULL_HANDLER,
66266
16
    ZEND_NULL_HANDLER,
66267
16
    ZEND_NULL_HANDLER,
66268
16
    ZEND_NULL_HANDLER,
66269
16
    ZEND_NULL_HANDLER,
66270
16
    ZEND_NULL_HANDLER,
66271
16
    ZEND_NULL_HANDLER,
66272
16
    ZEND_NULL_HANDLER,
66273
16
    ZEND_NULL_HANDLER,
66274
16
    ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
66275
16
    ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66276
16
    ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66277
16
    ZEND_NULL_HANDLER,
66278
16
    ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
66279
16
    ZEND_NULL_HANDLER,
66280
16
    ZEND_NULL_HANDLER,
66281
16
    ZEND_NULL_HANDLER,
66282
16
    ZEND_NULL_HANDLER,
66283
16
    ZEND_NULL_HANDLER,
66284
16
    ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
66285
16
    ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
66286
16
    ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
66287
16
    ZEND_NULL_HANDLER,
66288
16
    ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
66289
16
    ZEND_NULL_HANDLER,
66290
16
    ZEND_NULL_HANDLER,
66291
16
    ZEND_NULL_HANDLER,
66292
16
    ZEND_NULL_HANDLER,
66293
16
    ZEND_NULL_HANDLER,
66294
16
    ZEND_NULL_HANDLER,
66295
16
    ZEND_NULL_HANDLER,
66296
16
    ZEND_NULL_HANDLER,
66297
16
    ZEND_NULL_HANDLER,
66298
16
    ZEND_NULL_HANDLER,
66299
16
    ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
66300
16
    ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66301
16
    ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66302
16
    ZEND_NULL_HANDLER,
66303
16
    ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
66304
16
    ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
66305
16
    ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
66306
16
    ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
66307
16
    ZEND_NULL_HANDLER,
66308
16
    ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
66309
16
    ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
66310
16
    ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
66311
16
    ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
66312
16
    ZEND_NULL_HANDLER,
66313
16
    ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
66314
16
    ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER,
66315
16
    ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
66316
16
    ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
66317
16
    ZEND_NULL_HANDLER,
66318
16
    ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER,
66319
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66320
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66321
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66322
16
    ZEND_NULL_HANDLER,
66323
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66324
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66325
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66326
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66327
16
    ZEND_NULL_HANDLER,
66328
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66329
16
    ZEND_NULL_HANDLER,
66330
16
    ZEND_NULL_HANDLER,
66331
16
    ZEND_NULL_HANDLER,
66332
16
    ZEND_NULL_HANDLER,
66333
16
    ZEND_NULL_HANDLER,
66334
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66335
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66336
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66337
16
    ZEND_NULL_HANDLER,
66338
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66339
16
    ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
66340
16
    ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66341
16
    ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66342
16
    ZEND_NULL_HANDLER,
66343
16
    ZEND_NULL_HANDLER,
66344
16
    ZEND_NULL_HANDLER,
66345
16
    ZEND_NULL_HANDLER,
66346
16
    ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER,
66347
16
    ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER,
66348
16
    ZEND_NULL_HANDLER,
66349
16
    ZEND_NULL_HANDLER,
66350
16
    ZEND_EXT_STMT_SPEC_HANDLER,
66351
16
    ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
66352
16
    ZEND_EXT_FCALL_END_SPEC_HANDLER,
66353
16
    ZEND_EXT_NOP_SPEC_HANDLER,
66354
16
    ZEND_TICKS_SPEC_HANDLER,
66355
16
    ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER,
66356
16
    ZEND_NULL_HANDLER,
66357
16
    ZEND_NULL_HANDLER,
66358
16
    ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER,
66359
16
    ZEND_NULL_HANDLER,
66360
16
    ZEND_CATCH_SPEC_CONST_HANDLER,
66361
16
    ZEND_THROW_SPEC_CONST_HANDLER,
66362
16
    ZEND_THROW_SPEC_TMPVAR_HANDLER,
66363
16
    ZEND_THROW_SPEC_TMPVAR_HANDLER,
66364
16
    ZEND_NULL_HANDLER,
66365
16
    ZEND_THROW_SPEC_CV_HANDLER,
66366
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER,
66367
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
66368
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
66369
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66370
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER,
66371
16
    ZEND_CLONE_SPEC_CONST_HANDLER,
66372
16
    ZEND_CLONE_SPEC_TMPVAR_HANDLER,
66373
16
    ZEND_CLONE_SPEC_TMPVAR_HANDLER,
66374
16
    ZEND_CLONE_SPEC_UNUSED_HANDLER,
66375
16
    ZEND_CLONE_SPEC_CV_HANDLER,
66376
16
    ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
66377
16
    ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66378
16
    ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
66379
16
    ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66380
16
    ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
66381
16
    ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66382
16
    ZEND_NULL_HANDLER,
66383
16
    ZEND_NULL_HANDLER,
66384
16
    ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
66385
16
    ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66386
16
    ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
66387
16
    ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66388
16
    ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66389
16
    ZEND_NULL_HANDLER,
66390
16
    ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER,
66391
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
66392
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66393
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66394
16
    ZEND_NULL_HANDLER,
66395
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
66396
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
66397
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66398
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66399
16
    ZEND_NULL_HANDLER,
66400
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
66401
16
    ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
66402
16
    ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66403
16
    ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66404
16
    ZEND_NULL_HANDLER,
66405
16
    ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
66406
16
    ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
66407
16
    ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
66408
16
    ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
66409
16
    ZEND_NULL_HANDLER,
66410
16
    ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
66411
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
66412
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66413
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66414
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
66415
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
66416
16
    ZEND_NULL_HANDLER,
66417
16
    ZEND_NULL_HANDLER,
66418
16
    ZEND_NULL_HANDLER,
66419
16
    ZEND_NULL_HANDLER,
66420
16
    ZEND_NULL_HANDLER,
66421
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
66422
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
66423
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
66424
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
66425
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
66426
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
66427
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66428
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66429
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER,
66430
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
66431
16
    ZEND_NULL_HANDLER,
66432
16
    ZEND_NULL_HANDLER,
66433
16
    ZEND_NULL_HANDLER,
66434
16
    ZEND_NULL_HANDLER,
66435
16
    ZEND_NULL_HANDLER,
66436
16
    ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
66437
16
    ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
66438
16
    ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
66439
16
    ZEND_NULL_HANDLER,
66440
16
    ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
66441
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER,
66442
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66443
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66444
16
    ZEND_NULL_HANDLER,
66445
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER,
66446
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66447
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66448
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66449
16
    ZEND_NULL_HANDLER,
66450
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
66451
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66452
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66453
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66454
16
    ZEND_NULL_HANDLER,
66455
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
66456
16
    ZEND_NULL_HANDLER,
66457
16
    ZEND_NULL_HANDLER,
66458
16
    ZEND_NULL_HANDLER,
66459
16
    ZEND_NULL_HANDLER,
66460
16
    ZEND_NULL_HANDLER,
66461
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
66462
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
66463
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
66464
16
    ZEND_NULL_HANDLER,
66465
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
66466
16
    ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
66467
16
    ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
66468
16
    ZEND_NULL_HANDLER,
66469
16
    ZEND_NULL_HANDLER,
66470
16
    ZEND_NULL_HANDLER,
66471
16
    ZEND_NULL_HANDLER,
66472
16
    ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER,
66473
16
    ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER,
66474
16
    ZEND_NULL_HANDLER,
66475
16
    ZEND_NULL_HANDLER,
66476
16
    ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
66477
16
    ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
66478
16
    ZEND_NULL_HANDLER,
66479
16
    ZEND_NULL_HANDLER,
66480
16
    ZEND_NULL_HANDLER,
66481
16
    ZEND_NULL_HANDLER,
66482
16
    ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER,
66483
16
    ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER,
66484
16
    ZEND_NULL_HANDLER,
66485
16
    ZEND_NULL_HANDLER,
66486
16
    ZEND_NULL_HANDLER,
66487
16
    ZEND_NULL_HANDLER,
66488
16
    ZEND_NULL_HANDLER,
66489
16
    ZEND_NULL_HANDLER,
66490
16
    ZEND_NULL_HANDLER,
66491
16
    ZEND_NULL_HANDLER,
66492
16
    ZEND_NULL_HANDLER,
66493
16
    ZEND_NULL_HANDLER,
66494
16
    ZEND_NULL_HANDLER,
66495
16
    ZEND_NULL_HANDLER,
66496
16
    ZEND_NULL_HANDLER,
66497
16
    ZEND_NULL_HANDLER,
66498
16
    ZEND_NULL_HANDLER,
66499
16
    ZEND_NULL_HANDLER,
66500
16
    ZEND_NULL_HANDLER,
66501
16
    ZEND_NULL_HANDLER,
66502
16
    ZEND_NULL_HANDLER,
66503
16
    ZEND_NULL_HANDLER,
66504
16
    ZEND_NULL_HANDLER,
66505
16
    ZEND_NULL_HANDLER,
66506
16
    ZEND_NULL_HANDLER,
66507
16
    ZEND_NULL_HANDLER,
66508
16
    ZEND_NULL_HANDLER,
66509
16
    ZEND_NULL_HANDLER,
66510
16
    ZEND_NULL_HANDLER,
66511
16
    ZEND_NULL_HANDLER,
66512
16
    ZEND_NULL_HANDLER,
66513
16
    ZEND_NULL_HANDLER,
66514
16
    ZEND_NULL_HANDLER,
66515
16
    ZEND_NULL_HANDLER,
66516
16
    ZEND_NULL_HANDLER,
66517
16
    ZEND_NULL_HANDLER,
66518
16
    ZEND_NULL_HANDLER,
66519
16
    ZEND_NULL_HANDLER,
66520
16
    ZEND_NULL_HANDLER,
66521
16
    ZEND_NULL_HANDLER,
66522
16
    ZEND_NULL_HANDLER,
66523
16
    ZEND_NULL_HANDLER,
66524
16
    ZEND_NULL_HANDLER,
66525
16
    ZEND_NULL_HANDLER,
66526
16
    ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER,
66527
16
    ZEND_NULL_HANDLER,
66528
16
    ZEND_NULL_HANDLER,
66529
16
    ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER,
66530
16
    ZEND_NULL_HANDLER,
66531
16
    ZEND_NULL_HANDLER,
66532
16
    ZEND_NULL_HANDLER,
66533
16
    ZEND_NULL_HANDLER,
66534
16
    ZEND_NULL_HANDLER,
66535
16
    ZEND_NULL_HANDLER,
66536
16
    ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER,
66537
16
    ZEND_NULL_HANDLER,
66538
16
    ZEND_NULL_HANDLER,
66539
16
    ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER,
66540
16
    ZEND_NULL_HANDLER,
66541
16
    ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER,
66542
16
    ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
66543
16
    ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
66544
16
    ZEND_NULL_HANDLER,
66545
16
    ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER,
66546
16
    ZEND_SEND_ARRAY_SPEC_HANDLER,
66547
16
    ZEND_SEND_USER_SPEC_CONST_HANDLER,
66548
16
    ZEND_SEND_USER_SPEC_TMP_HANDLER,
66549
16
    ZEND_SEND_USER_SPEC_VAR_HANDLER,
66550
16
    ZEND_NULL_HANDLER,
66551
16
    ZEND_SEND_USER_SPEC_CV_HANDLER,
66552
16
    ZEND_STRLEN_SPEC_CONST_HANDLER,
66553
16
    ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
66554
16
    ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
66555
16
    ZEND_NULL_HANDLER,
66556
16
    ZEND_STRLEN_SPEC_CV_HANDLER,
66557
16
    ZEND_DEFINED_SPEC_CONST_HANDLER,
66558
16
    ZEND_TYPE_CHECK_SPEC_CONST_HANDLER,
66559
16
    ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
66560
16
    ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
66561
16
    ZEND_NULL_HANDLER,
66562
16
    ZEND_TYPE_CHECK_SPEC_CV_HANDLER,
66563
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER,
66564
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER,
66565
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER,
66566
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
66567
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER,
66568
16
    ZEND_FE_RESET_RW_SPEC_CONST_HANDLER,
66569
16
    ZEND_FE_RESET_RW_SPEC_TMP_HANDLER,
66570
16
    ZEND_FE_RESET_RW_SPEC_VAR_HANDLER,
66571
16
    ZEND_NULL_HANDLER,
66572
16
    ZEND_FE_RESET_RW_SPEC_CV_HANDLER,
66573
16
    ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER,
66574
16
    ZEND_FE_FREE_SPEC_TMPVAR_HANDLER,
66575
16
    ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER,
66576
16
    ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
66577
16
    ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
66578
16
    ZEND_NULL_HANDLER,
66579
16
    ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER,
66580
16
    ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER,
66581
16
    ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER,
66582
16
    ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
66583
16
    ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
66584
16
    ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER,
66585
16
    ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER,
66586
16
    ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
66587
16
    ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
66588
16
    ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER,
66589
16
    ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER,
66590
16
    ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
66591
16
    ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
66592
16
    ZEND_NULL_HANDLER,
66593
16
    ZEND_NULL_HANDLER,
66594
16
    ZEND_NULL_HANDLER,
66595
16
    ZEND_NULL_HANDLER,
66596
16
    ZEND_NULL_HANDLER,
66597
16
    ZEND_NULL_HANDLER,
66598
16
    ZEND_NULL_HANDLER,
66599
16
    ZEND_NULL_HANDLER,
66600
16
    ZEND_NULL_HANDLER,
66601
16
    ZEND_NULL_HANDLER,
66602
16
    ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
66603
16
    ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66604
16
    ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66605
16
    ZEND_NULL_HANDLER,
66606
16
    ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
66607
16
    ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
66608
16
    ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66609
16
    ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66610
16
    ZEND_NULL_HANDLER,
66611
16
    ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
66612
16
    ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
66613
16
    ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66614
16
    ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66615
16
    ZEND_NULL_HANDLER,
66616
16
    ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
66617
16
    ZEND_NULL_HANDLER,
66618
16
    ZEND_NULL_HANDLER,
66619
16
    ZEND_NULL_HANDLER,
66620
16
    ZEND_NULL_HANDLER,
66621
16
    ZEND_NULL_HANDLER,
66622
16
    ZEND_NULL_HANDLER,
66623
16
    ZEND_NULL_HANDLER,
66624
16
    ZEND_NULL_HANDLER,
66625
16
    ZEND_NULL_HANDLER,
66626
16
    ZEND_NULL_HANDLER,
66627
16
    ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
66628
16
    ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66629
16
    ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66630
16
    ZEND_NULL_HANDLER,
66631
16
    ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
66632
16
    ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
66633
16
    ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66634
16
    ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66635
16
    ZEND_NULL_HANDLER,
66636
16
    ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
66637
16
    ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
66638
16
    ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66639
16
    ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66640
16
    ZEND_NULL_HANDLER,
66641
16
    ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
66642
16
    ZEND_ECHO_SPEC_CONST_HANDLER,
66643
16
    ZEND_ECHO_SPEC_TMPVAR_HANDLER,
66644
16
    ZEND_ECHO_SPEC_TMPVAR_HANDLER,
66645
16
    ZEND_NULL_HANDLER,
66646
16
    ZEND_ECHO_SPEC_CV_HANDLER,
66647
16
    ZEND_NULL_HANDLER,
66648
16
    ZEND_NULL_HANDLER,
66649
16
    ZEND_NULL_HANDLER,
66650
16
    ZEND_NULL_HANDLER,
66651
16
    ZEND_NULL_HANDLER,
66652
16
    ZEND_NULL_HANDLER,
66653
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
66654
16
    ZEND_NULL_HANDLER,
66655
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
66656
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
66657
16
    ZEND_NULL_HANDLER,
66658
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
66659
16
    ZEND_NULL_HANDLER,
66660
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
66661
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
66662
16
    ZEND_NULL_HANDLER,
66663
16
    ZEND_NULL_HANDLER,
66664
16
    ZEND_NULL_HANDLER,
66665
16
    ZEND_NULL_HANDLER,
66666
16
    ZEND_NULL_HANDLER,
66667
16
    ZEND_NULL_HANDLER,
66668
16
    ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER,
66669
16
    ZEND_NULL_HANDLER,
66670
16
    ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER,
66671
16
    ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER,
66672
16
    ZEND_NULL_HANDLER,
66673
16
    ZEND_GENERATOR_CREATE_SPEC_HANDLER,
66674
16
    ZEND_NULL_HANDLER,
66675
16
    ZEND_NULL_HANDLER,
66676
16
    ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER,
66677
16
    ZEND_NULL_HANDLER,
66678
16
    ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER,
66679
16
    ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
66680
16
    ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER,
66681
16
    ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
66682
16
    ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER,
66683
16
    ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER,
66684
16
    ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
66685
16
    ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER,
66686
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER,
66687
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66688
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66689
16
    ZEND_NULL_HANDLER,
66690
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER,
66691
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66692
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66693
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66694
16
    ZEND_NULL_HANDLER,
66695
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
66696
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66697
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66698
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66699
16
    ZEND_NULL_HANDLER,
66700
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
66701
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
66702
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66703
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66704
16
    ZEND_NULL_HANDLER,
66705
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
66706
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
66707
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
66708
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
66709
16
    ZEND_NULL_HANDLER,
66710
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
66711
16
    ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
66712
16
    ZEND_USER_OPCODE_SPEC_HANDLER,
66713
16
    ZEND_ASSERT_CHECK_SPEC_HANDLER,
66714
16
    ZEND_JMP_SET_SPEC_CONST_HANDLER,
66715
16
    ZEND_JMP_SET_SPEC_TMP_HANDLER,
66716
16
    ZEND_JMP_SET_SPEC_VAR_HANDLER,
66717
16
    ZEND_NULL_HANDLER,
66718
16
    ZEND_JMP_SET_SPEC_CV_HANDLER,
66719
16
    ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER,
66720
16
    ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER,
66721
16
    ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER,
66722
16
    ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER,
66723
16
    ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
66724
16
    ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
66725
16
    ZEND_NULL_HANDLER,
66726
16
    ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER,
66727
16
    ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
66728
16
    ZEND_NULL_HANDLER,
66729
16
    ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
66730
16
    ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
66731
16
    ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
66732
16
    ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER,
66733
16
    ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
66734
16
    ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER,
66735
16
    ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
66736
16
    ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
66737
16
    ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
66738
16
    ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
66739
16
    ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER,
66740
16
    ZEND_YIELD_SPEC_CONST_CV_HANDLER,
66741
16
    ZEND_YIELD_SPEC_TMP_CONST_HANDLER,
66742
16
    ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
66743
16
    ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
66744
16
    ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER,
66745
16
    ZEND_YIELD_SPEC_TMP_CV_HANDLER,
66746
16
    ZEND_YIELD_SPEC_VAR_CONST_HANDLER,
66747
16
    ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
66748
16
    ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
66749
16
    ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER,
66750
16
    ZEND_YIELD_SPEC_VAR_CV_HANDLER,
66751
16
    ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER,
66752
16
    ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
66753
16
    ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
66754
16
    ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER,
66755
16
    ZEND_YIELD_SPEC_UNUSED_CV_HANDLER,
66756
16
    ZEND_YIELD_SPEC_CV_CONST_HANDLER,
66757
16
    ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
66758
16
    ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
66759
16
    ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
66760
16
    ZEND_YIELD_SPEC_CV_CV_HANDLER,
66761
16
    ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER,
66762
16
    ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66763
16
    ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER,
66764
16
    ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66765
16
    ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER,
66766
16
    ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66767
16
    ZEND_NULL_HANDLER,
66768
16
    ZEND_NULL_HANDLER,
66769
16
    ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER,
66770
16
    ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66771
16
    ZEND_FAST_CALL_SPEC_HANDLER,
66772
16
    ZEND_FAST_RET_SPEC_HANDLER,
66773
16
    ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER,
66774
16
    ZEND_SEND_UNPACK_SPEC_HANDLER,
66775
16
    ZEND_YIELD_FROM_SPEC_CONST_HANDLER,
66776
16
    ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
66777
16
    ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
66778
16
    ZEND_NULL_HANDLER,
66779
16
    ZEND_YIELD_FROM_SPEC_CV_HANDLER,
66780
16
    ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER,
66781
16
    ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER,
66782
16
    ZEND_COALESCE_SPEC_CONST_HANDLER,
66783
16
    ZEND_COALESCE_SPEC_TMP_HANDLER,
66784
16
    ZEND_COALESCE_SPEC_VAR_HANDLER,
66785
16
    ZEND_NULL_HANDLER,
66786
16
    ZEND_COALESCE_SPEC_CV_HANDLER,
66787
16
    ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER,
66788
16
    ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
66789
16
    ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
66790
16
    ZEND_NULL_HANDLER,
66791
16
    ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER,
66792
16
    ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
66793
16
    ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66794
16
    ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66795
16
    ZEND_NULL_HANDLER,
66796
16
    ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
66797
16
    ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
66798
16
    ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66799
16
    ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66800
16
    ZEND_NULL_HANDLER,
66801
16
    ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
66802
16
    ZEND_NULL_HANDLER,
66803
16
    ZEND_NULL_HANDLER,
66804
16
    ZEND_NULL_HANDLER,
66805
16
    ZEND_NULL_HANDLER,
66806
16
    ZEND_NULL_HANDLER,
66807
16
    ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER,
66808
16
    ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
66809
16
    ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
66810
16
    ZEND_NULL_HANDLER,
66811
16
    ZEND_SPACESHIP_SPEC_CV_CV_HANDLER,
66812
16
    ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66813
16
    ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER,
66814
16
    ZEND_NULL_HANDLER,
66815
16
    ZEND_NULL_HANDLER,
66816
16
    ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66817
16
    ZEND_NULL_HANDLER,
66818
16
    ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER,
66819
16
    ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER,
66820
16
    ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER,
66821
16
    ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER,
66822
16
    ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER,
66823
16
    ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER,
66824
16
    ZEND_UNSET_STATIC_PROP_SPEC_HANDLER,
66825
16
    ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER,
66826
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER,
66827
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66828
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66829
16
    ZEND_NULL_HANDLER,
66830
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66831
16
    ZEND_NULL_HANDLER,
66832
16
    ZEND_NULL_HANDLER,
66833
16
    ZEND_NULL_HANDLER,
66834
16
    ZEND_NULL_HANDLER,
66835
16
    ZEND_NULL_HANDLER,
66836
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER,
66837
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66838
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66839
16
    ZEND_NULL_HANDLER,
66840
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66841
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
66842
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66843
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66844
16
    ZEND_NULL_HANDLER,
66845
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66846
16
    ZEND_NULL_HANDLER,
66847
16
    ZEND_NULL_HANDLER,
66848
16
    ZEND_NULL_HANDLER,
66849
16
    ZEND_NULL_HANDLER,
66850
16
    ZEND_NULL_HANDLER,
66851
16
    ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER,
66852
16
    ZEND_BIND_STATIC_SPEC_CV_HANDLER,
66853
16
    ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER,
66854
16
    ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66855
16
    ZEND_NULL_HANDLER,
66856
16
    ZEND_NULL_HANDLER,
66857
16
    ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
66858
16
    ZEND_NULL_HANDLER,
66859
16
    ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER,
66860
16
    ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER,
66861
16
    ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66862
16
    ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66863
16
    ZEND_NULL_HANDLER,
66864
16
    ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66865
16
    ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER,
66866
16
    ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66867
16
    ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66868
16
    ZEND_NULL_HANDLER,
66869
16
    ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66870
16
    ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER,
66871
16
    ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER,
66872
16
    ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER,
66873
16
    ZEND_NULL_HANDLER,
66874
16
    ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER,
66875
16
    ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER,
66876
16
    ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
66877
16
    ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
66878
16
    ZEND_NULL_HANDLER,
66879
16
    ZEND_COUNT_SPEC_CV_UNUSED_HANDLER,
66880
16
    ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER,
66881
16
    ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
66882
16
    ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
66883
16
    ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66884
16
    ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER,
66885
16
    ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66886
16
    ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER,
66887
16
    ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER,
66888
16
    ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER,
66889
16
    ZEND_NULL_HANDLER,
66890
16
    ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER,
66891
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER,
66892
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
66893
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
66894
16
    ZEND_NULL_HANDLER,
66895
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER,
66896
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
66897
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66898
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66899
16
    ZEND_NULL_HANDLER,
66900
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
66901
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
66902
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66903
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66904
16
    ZEND_NULL_HANDLER,
66905
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
66906
16
    ZEND_NULL_HANDLER,
66907
16
    ZEND_NULL_HANDLER,
66908
16
    ZEND_NULL_HANDLER,
66909
16
    ZEND_NULL_HANDLER,
66910
16
    ZEND_NULL_HANDLER,
66911
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER,
66912
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
66913
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
66914
16
    ZEND_NULL_HANDLER,
66915
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER,
66916
16
    ZEND_MATCH_SPEC_CONST_CONST_HANDLER,
66917
16
    ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66918
16
    ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66919
16
    ZEND_NULL_HANDLER,
66920
16
    ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66921
16
    ZEND_NULL_HANDLER,
66922
16
    ZEND_NULL_HANDLER,
66923
16
    ZEND_NULL_HANDLER,
66924
16
    ZEND_NULL_HANDLER,
66925
16
    ZEND_NULL_HANDLER,
66926
16
    ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER,
66927
16
    ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER,
66928
16
    ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER,
66929
16
    ZEND_NULL_HANDLER,
66930
16
    ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER,
66931
16
    ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER,
66932
16
    ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER,
66933
16
    ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER,
66934
16
    ZEND_NULL_HANDLER,
66935
16
    ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER,
66936
16
    ZEND_NULL_HANDLER,
66937
16
    ZEND_NULL_HANDLER,
66938
16
    ZEND_NULL_HANDLER,
66939
16
    ZEND_NULL_HANDLER,
66940
16
    ZEND_NULL_HANDLER,
66941
16
    ZEND_NULL_HANDLER,
66942
16
    ZEND_NULL_HANDLER,
66943
16
    ZEND_NULL_HANDLER,
66944
16
    ZEND_NULL_HANDLER,
66945
16
    ZEND_NULL_HANDLER,
66946
16
    ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER,
66947
16
    ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66948
16
    ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66949
16
    ZEND_NULL_HANDLER,
66950
16
    ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66951
16
    ZEND_JMP_NULL_SPEC_CONST_HANDLER,
66952
16
    ZEND_JMP_NULL_SPEC_TMP_HANDLER,
66953
16
    ZEND_JMP_NULL_SPEC_VAR_HANDLER,
66954
16
    ZEND_NULL_HANDLER,
66955
16
    ZEND_JMP_NULL_SPEC_CV_HANDLER,
66956
16
    ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66957
16
    ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER,
66958
16
    ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
66959
16
    ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER,
66960
16
    ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER,
66961
16
    ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER,
66962
16
    ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER,
66963
16
    ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER,
66964
16
    ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER,
66965
16
    ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER,
66966
16
    ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER,
66967
16
    ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER,
66968
16
    ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER,
66969
16
    ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
66970
16
    ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER,
66971
16
    ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER,
66972
16
    ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
66973
16
    ZEND_RECV_NOTYPE_SPEC_HANDLER,
66974
16
    ZEND_NULL_HANDLER,
66975
16
    ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
66976
16
    ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
66977
16
    ZEND_NULL_HANDLER,
66978
16
    ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER,
66979
16
    ZEND_JMP_FORWARD_SPEC_HANDLER,
66980
16
    ZEND_NULL_HANDLER,
66981
16
    ZEND_NULL_HANDLER,
66982
16
    ZEND_NULL_HANDLER,
66983
16
    ZEND_NULL_HANDLER,
66984
16
    ZEND_NULL_HANDLER,
66985
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66986
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66987
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66988
16
    ZEND_NULL_HANDLER,
66989
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66990
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66991
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66992
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66993
16
    ZEND_NULL_HANDLER,
66994
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66995
16
    ZEND_NULL_HANDLER,
66996
16
    ZEND_NULL_HANDLER,
66997
16
    ZEND_NULL_HANDLER,
66998
16
    ZEND_NULL_HANDLER,
66999
16
    ZEND_NULL_HANDLER,
67000
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67001
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67002
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67003
16
    ZEND_NULL_HANDLER,
67004
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67005
16
    ZEND_NULL_HANDLER,
67006
16
    ZEND_NULL_HANDLER,
67007
16
    ZEND_NULL_HANDLER,
67008
16
    ZEND_NULL_HANDLER,
67009
16
    ZEND_NULL_HANDLER,
67010
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67011
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67012
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67013
16
    ZEND_NULL_HANDLER,
67014
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67015
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67016
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67017
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67018
16
    ZEND_NULL_HANDLER,
67019
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67020
16
    ZEND_NULL_HANDLER,
67021
16
    ZEND_NULL_HANDLER,
67022
16
    ZEND_NULL_HANDLER,
67023
16
    ZEND_NULL_HANDLER,
67024
16
    ZEND_NULL_HANDLER,
67025
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67026
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67027
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67028
16
    ZEND_NULL_HANDLER,
67029
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67030
16
    ZEND_NULL_HANDLER,
67031
16
    ZEND_NULL_HANDLER,
67032
16
    ZEND_NULL_HANDLER,
67033
16
    ZEND_NULL_HANDLER,
67034
16
    ZEND_NULL_HANDLER,
67035
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67036
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67037
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67038
16
    ZEND_NULL_HANDLER,
67039
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67040
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67041
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67042
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67043
16
    ZEND_NULL_HANDLER,
67044
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67045
16
    ZEND_NULL_HANDLER,
67046
16
    ZEND_NULL_HANDLER,
67047
16
    ZEND_NULL_HANDLER,
67048
16
    ZEND_NULL_HANDLER,
67049
16
    ZEND_NULL_HANDLER,
67050
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67051
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67052
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67053
16
    ZEND_NULL_HANDLER,
67054
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67055
16
    ZEND_NULL_HANDLER,
67056
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
67057
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
67058
16
    ZEND_NULL_HANDLER,
67059
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
67060
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67061
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67062
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67063
16
    ZEND_NULL_HANDLER,
67064
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67065
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67066
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67067
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67068
16
    ZEND_NULL_HANDLER,
67069
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67070
16
    ZEND_NULL_HANDLER,
67071
16
    ZEND_NULL_HANDLER,
67072
16
    ZEND_NULL_HANDLER,
67073
16
    ZEND_NULL_HANDLER,
67074
16
    ZEND_NULL_HANDLER,
67075
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67076
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67077
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67078
16
    ZEND_NULL_HANDLER,
67079
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67080
16
    ZEND_NULL_HANDLER,
67081
16
    ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67082
16
    ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67083
16
    ZEND_NULL_HANDLER,
67084
16
    ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67085
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67086
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67087
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67088
16
    ZEND_NULL_HANDLER,
67089
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67090
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67091
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67092
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67093
16
    ZEND_NULL_HANDLER,
67094
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67095
16
    ZEND_NULL_HANDLER,
67096
16
    ZEND_NULL_HANDLER,
67097
16
    ZEND_NULL_HANDLER,
67098
16
    ZEND_NULL_HANDLER,
67099
16
    ZEND_NULL_HANDLER,
67100
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67101
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67102
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67103
16
    ZEND_NULL_HANDLER,
67104
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67105
16
    ZEND_NULL_HANDLER,
67106
16
    ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67107
16
    ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67108
16
    ZEND_NULL_HANDLER,
67109
16
    ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67110
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67111
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67112
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67113
16
    ZEND_NULL_HANDLER,
67114
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67115
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67116
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67117
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67118
16
    ZEND_NULL_HANDLER,
67119
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67120
16
    ZEND_NULL_HANDLER,
67121
16
    ZEND_NULL_HANDLER,
67122
16
    ZEND_NULL_HANDLER,
67123
16
    ZEND_NULL_HANDLER,
67124
16
    ZEND_NULL_HANDLER,
67125
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67126
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67127
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67128
16
    ZEND_NULL_HANDLER,
67129
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67130
16
    ZEND_NULL_HANDLER,
67131
16
    ZEND_NULL_HANDLER,
67132
16
    ZEND_NULL_HANDLER,
67133
16
    ZEND_NULL_HANDLER,
67134
16
    ZEND_NULL_HANDLER,
67135
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67136
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67137
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67138
16
    ZEND_NULL_HANDLER,
67139
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67140
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67141
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67142
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67143
16
    ZEND_NULL_HANDLER,
67144
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67145
16
    ZEND_NULL_HANDLER,
67146
16
    ZEND_NULL_HANDLER,
67147
16
    ZEND_NULL_HANDLER,
67148
16
    ZEND_NULL_HANDLER,
67149
16
    ZEND_NULL_HANDLER,
67150
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67151
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67152
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67153
16
    ZEND_NULL_HANDLER,
67154
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67155
16
    ZEND_NULL_HANDLER,
67156
16
    ZEND_NULL_HANDLER,
67157
16
    ZEND_NULL_HANDLER,
67158
16
    ZEND_NULL_HANDLER,
67159
16
    ZEND_NULL_HANDLER,
67160
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67161
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67162
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67163
16
    ZEND_NULL_HANDLER,
67164
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67165
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67166
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67167
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67168
16
    ZEND_NULL_HANDLER,
67169
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67170
16
    ZEND_NULL_HANDLER,
67171
16
    ZEND_NULL_HANDLER,
67172
16
    ZEND_NULL_HANDLER,
67173
16
    ZEND_NULL_HANDLER,
67174
16
    ZEND_NULL_HANDLER,
67175
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67176
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67177
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67178
16
    ZEND_NULL_HANDLER,
67179
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67180
16
    ZEND_NULL_HANDLER,
67181
16
    ZEND_NULL_HANDLER,
67182
16
    ZEND_NULL_HANDLER,
67183
16
    ZEND_NULL_HANDLER,
67184
16
    ZEND_NULL_HANDLER,
67185
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67186
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67187
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67188
16
    ZEND_NULL_HANDLER,
67189
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67190
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67191
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67192
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67193
16
    ZEND_NULL_HANDLER,
67194
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67195
16
    ZEND_NULL_HANDLER,
67196
16
    ZEND_NULL_HANDLER,
67197
16
    ZEND_NULL_HANDLER,
67198
16
    ZEND_NULL_HANDLER,
67199
16
    ZEND_NULL_HANDLER,
67200
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67201
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67202
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67203
16
    ZEND_NULL_HANDLER,
67204
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67205
16
    ZEND_NULL_HANDLER,
67206
16
    ZEND_NULL_HANDLER,
67207
16
    ZEND_NULL_HANDLER,
67208
16
    ZEND_NULL_HANDLER,
67209
16
    ZEND_NULL_HANDLER,
67210
16
    ZEND_NULL_HANDLER,
67211
16
    ZEND_NULL_HANDLER,
67212
16
    ZEND_NULL_HANDLER,
67213
16
    ZEND_NULL_HANDLER,
67214
16
    ZEND_NULL_HANDLER,
67215
16
    ZEND_NULL_HANDLER,
67216
16
    ZEND_NULL_HANDLER,
67217
16
    ZEND_NULL_HANDLER,
67218
16
    ZEND_NULL_HANDLER,
67219
16
    ZEND_NULL_HANDLER,
67220
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67221
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67222
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67223
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67224
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67225
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67226
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67227
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67228
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67229
16
    ZEND_NULL_HANDLER,
67230
16
    ZEND_NULL_HANDLER,
67231
16
    ZEND_NULL_HANDLER,
67232
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67233
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67234
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67235
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67236
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67237
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67238
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67239
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67240
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67241
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67242
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67243
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67244
16
    ZEND_NULL_HANDLER,
67245
16
    ZEND_NULL_HANDLER,
67246
16
    ZEND_NULL_HANDLER,
67247
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67248
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67249
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67250
16
    ZEND_NULL_HANDLER,
67251
16
    ZEND_NULL_HANDLER,
67252
16
    ZEND_NULL_HANDLER,
67253
16
    ZEND_NULL_HANDLER,
67254
16
    ZEND_NULL_HANDLER,
67255
16
    ZEND_NULL_HANDLER,
67256
16
    ZEND_NULL_HANDLER,
67257
16
    ZEND_NULL_HANDLER,
67258
16
    ZEND_NULL_HANDLER,
67259
16
    ZEND_NULL_HANDLER,
67260
16
    ZEND_NULL_HANDLER,
67261
16
    ZEND_NULL_HANDLER,
67262
16
    ZEND_NULL_HANDLER,
67263
16
    ZEND_NULL_HANDLER,
67264
16
    ZEND_NULL_HANDLER,
67265
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67266
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67267
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67268
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67269
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67270
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67271
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67272
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67273
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67274
16
    ZEND_NULL_HANDLER,
67275
16
    ZEND_NULL_HANDLER,
67276
16
    ZEND_NULL_HANDLER,
67277
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67278
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67279
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67280
16
    ZEND_NULL_HANDLER,
67281
16
    ZEND_NULL_HANDLER,
67282
16
    ZEND_NULL_HANDLER,
67283
16
    ZEND_NULL_HANDLER,
67284
16
    ZEND_NULL_HANDLER,
67285
16
    ZEND_NULL_HANDLER,
67286
16
    ZEND_NULL_HANDLER,
67287
16
    ZEND_NULL_HANDLER,
67288
16
    ZEND_NULL_HANDLER,
67289
16
    ZEND_NULL_HANDLER,
67290
16
    ZEND_NULL_HANDLER,
67291
16
    ZEND_NULL_HANDLER,
67292
16
    ZEND_NULL_HANDLER,
67293
16
    ZEND_NULL_HANDLER,
67294
16
    ZEND_NULL_HANDLER,
67295
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67296
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67297
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67298
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67299
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67300
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67301
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67302
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67303
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67304
16
    ZEND_NULL_HANDLER,
67305
16
    ZEND_NULL_HANDLER,
67306
16
    ZEND_NULL_HANDLER,
67307
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67308
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67309
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67310
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67311
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67312
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67313
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67314
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67315
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67316
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67317
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67318
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67319
16
    ZEND_NULL_HANDLER,
67320
16
    ZEND_NULL_HANDLER,
67321
16
    ZEND_NULL_HANDLER,
67322
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67323
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67324
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67325
16
    ZEND_NULL_HANDLER,
67326
16
    ZEND_NULL_HANDLER,
67327
16
    ZEND_NULL_HANDLER,
67328
16
    ZEND_NULL_HANDLER,
67329
16
    ZEND_NULL_HANDLER,
67330
16
    ZEND_NULL_HANDLER,
67331
16
    ZEND_NULL_HANDLER,
67332
16
    ZEND_NULL_HANDLER,
67333
16
    ZEND_NULL_HANDLER,
67334
16
    ZEND_NULL_HANDLER,
67335
16
    ZEND_NULL_HANDLER,
67336
16
    ZEND_NULL_HANDLER,
67337
16
    ZEND_NULL_HANDLER,
67338
16
    ZEND_NULL_HANDLER,
67339
16
    ZEND_NULL_HANDLER,
67340
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67341
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67342
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67343
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67344
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67345
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67346
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67347
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67348
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67349
16
    ZEND_NULL_HANDLER,
67350
16
    ZEND_NULL_HANDLER,
67351
16
    ZEND_NULL_HANDLER,
67352
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67353
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67354
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67355
16
    ZEND_NULL_HANDLER,
67356
16
    ZEND_NULL_HANDLER,
67357
16
    ZEND_NULL_HANDLER,
67358
16
    ZEND_NULL_HANDLER,
67359
16
    ZEND_NULL_HANDLER,
67360
16
    ZEND_NULL_HANDLER,
67361
16
    ZEND_NULL_HANDLER,
67362
16
    ZEND_NULL_HANDLER,
67363
16
    ZEND_NULL_HANDLER,
67364
16
    ZEND_NULL_HANDLER,
67365
16
    ZEND_NULL_HANDLER,
67366
16
    ZEND_NULL_HANDLER,
67367
16
    ZEND_NULL_HANDLER,
67368
16
    ZEND_NULL_HANDLER,
67369
16
    ZEND_NULL_HANDLER,
67370
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67371
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67372
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67373
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67374
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67375
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67376
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67377
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67378
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67379
16
    ZEND_NULL_HANDLER,
67380
16
    ZEND_NULL_HANDLER,
67381
16
    ZEND_NULL_HANDLER,
67382
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67383
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67384
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67385
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67386
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67387
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67388
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67389
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67390
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67391
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67392
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67393
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67394
16
    ZEND_NULL_HANDLER,
67395
16
    ZEND_NULL_HANDLER,
67396
16
    ZEND_NULL_HANDLER,
67397
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67398
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67399
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67400
16
    ZEND_NULL_HANDLER,
67401
16
    ZEND_NULL_HANDLER,
67402
16
    ZEND_NULL_HANDLER,
67403
16
    ZEND_NULL_HANDLER,
67404
16
    ZEND_NULL_HANDLER,
67405
16
    ZEND_NULL_HANDLER,
67406
16
    ZEND_NULL_HANDLER,
67407
16
    ZEND_NULL_HANDLER,
67408
16
    ZEND_NULL_HANDLER,
67409
16
    ZEND_NULL_HANDLER,
67410
16
    ZEND_NULL_HANDLER,
67411
16
    ZEND_NULL_HANDLER,
67412
16
    ZEND_NULL_HANDLER,
67413
16
    ZEND_NULL_HANDLER,
67414
16
    ZEND_NULL_HANDLER,
67415
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67416
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67417
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67418
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67419
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67420
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67421
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67422
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67423
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67424
16
    ZEND_NULL_HANDLER,
67425
16
    ZEND_NULL_HANDLER,
67426
16
    ZEND_NULL_HANDLER,
67427
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67428
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67429
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67430
16
    ZEND_NULL_HANDLER,
67431
16
    ZEND_NULL_HANDLER,
67432
16
    ZEND_NULL_HANDLER,
67433
16
    ZEND_NULL_HANDLER,
67434
16
    ZEND_NULL_HANDLER,
67435
16
    ZEND_NULL_HANDLER,
67436
16
    ZEND_NULL_HANDLER,
67437
16
    ZEND_NULL_HANDLER,
67438
16
    ZEND_NULL_HANDLER,
67439
16
    ZEND_NULL_HANDLER,
67440
16
    ZEND_NULL_HANDLER,
67441
16
    ZEND_NULL_HANDLER,
67442
16
    ZEND_NULL_HANDLER,
67443
16
    ZEND_NULL_HANDLER,
67444
16
    ZEND_NULL_HANDLER,
67445
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67446
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67447
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67448
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67449
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67450
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67451
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67452
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67453
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67454
16
    ZEND_NULL_HANDLER,
67455
16
    ZEND_NULL_HANDLER,
67456
16
    ZEND_NULL_HANDLER,
67457
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67458
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67459
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67460
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67461
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67462
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67463
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67464
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67465
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67466
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67467
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67468
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67469
16
    ZEND_NULL_HANDLER,
67470
16
    ZEND_NULL_HANDLER,
67471
16
    ZEND_NULL_HANDLER,
67472
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67473
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67474
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67475
16
    ZEND_NULL_HANDLER,
67476
16
    ZEND_NULL_HANDLER,
67477
16
    ZEND_NULL_HANDLER,
67478
16
    ZEND_NULL_HANDLER,
67479
16
    ZEND_NULL_HANDLER,
67480
16
    ZEND_NULL_HANDLER,
67481
16
    ZEND_NULL_HANDLER,
67482
16
    ZEND_NULL_HANDLER,
67483
16
    ZEND_NULL_HANDLER,
67484
16
    ZEND_NULL_HANDLER,
67485
16
    ZEND_NULL_HANDLER,
67486
16
    ZEND_NULL_HANDLER,
67487
16
    ZEND_NULL_HANDLER,
67488
16
    ZEND_NULL_HANDLER,
67489
16
    ZEND_NULL_HANDLER,
67490
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67491
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67492
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67493
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67494
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67495
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67496
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67497
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67498
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67499
16
    ZEND_NULL_HANDLER,
67500
16
    ZEND_NULL_HANDLER,
67501
16
    ZEND_NULL_HANDLER,
67502
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67503
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67504
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67505
16
    ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER,
67506
16
    ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67507
16
    ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67508
16
    ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER,
67509
16
    ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67510
16
    ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67511
16
    ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
67512
16
    ZEND_NULL_HANDLER,
67513
16
    ZEND_NULL_HANDLER,
67514
16
    ZEND_NULL_HANDLER,
67515
16
    ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
67516
16
    ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
67517
16
    ZEND_NULL_HANDLER,
67518
16
    ZEND_NULL_HANDLER,
67519
16
    ZEND_NULL_HANDLER,
67520
16
    ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
67521
16
    ZEND_NULL_HANDLER,
67522
16
    ZEND_NULL_HANDLER,
67523
16
    ZEND_NULL_HANDLER,
67524
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67525
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67526
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67527
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67528
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67529
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67530
16
    ZEND_NULL_HANDLER,
67531
16
    ZEND_NULL_HANDLER,
67532
16
    ZEND_NULL_HANDLER,
67533
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67534
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67535
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67536
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67537
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67538
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67539
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67540
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67541
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67542
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67543
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67544
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67545
16
    ZEND_NULL_HANDLER,
67546
16
    ZEND_NULL_HANDLER,
67547
16
    ZEND_NULL_HANDLER,
67548
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67549
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67550
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67551
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67552
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67553
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67554
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67555
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67556
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67557
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67558
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67559
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67560
16
    ZEND_NULL_HANDLER,
67561
16
    ZEND_NULL_HANDLER,
67562
16
    ZEND_NULL_HANDLER,
67563
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67564
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67565
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67566
16
    ZEND_NULL_HANDLER,
67567
16
    ZEND_NULL_HANDLER,
67568
16
    ZEND_NULL_HANDLER,
67569
16
    ZEND_NULL_HANDLER,
67570
16
    ZEND_NULL_HANDLER,
67571
16
    ZEND_NULL_HANDLER,
67572
16
    ZEND_NULL_HANDLER,
67573
16
    ZEND_NULL_HANDLER,
67574
16
    ZEND_NULL_HANDLER,
67575
16
    ZEND_NULL_HANDLER,
67576
16
    ZEND_NULL_HANDLER,
67577
16
    ZEND_NULL_HANDLER,
67578
16
    ZEND_NULL_HANDLER,
67579
16
    ZEND_NULL_HANDLER,
67580
16
    ZEND_NULL_HANDLER,
67581
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67582
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67583
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67584
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67585
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67586
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67587
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67588
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67589
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67590
16
    ZEND_NULL_HANDLER,
67591
16
    ZEND_NULL_HANDLER,
67592
16
    ZEND_NULL_HANDLER,
67593
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67594
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67595
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67596
16
    ZEND_NULL_HANDLER,
67597
16
    ZEND_NULL_HANDLER,
67598
16
    ZEND_NULL_HANDLER,
67599
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67600
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67601
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67602
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67603
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67604
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67605
16
    ZEND_NULL_HANDLER,
67606
16
    ZEND_NULL_HANDLER,
67607
16
    ZEND_NULL_HANDLER,
67608
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67609
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67610
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67611
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67612
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67613
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67614
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67615
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67616
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67617
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67618
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67619
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67620
16
    ZEND_NULL_HANDLER,
67621
16
    ZEND_NULL_HANDLER,
67622
16
    ZEND_NULL_HANDLER,
67623
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67624
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67625
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67626
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67627
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67628
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67629
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67630
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67631
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67632
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67633
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67634
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67635
16
    ZEND_NULL_HANDLER,
67636
16
    ZEND_NULL_HANDLER,
67637
16
    ZEND_NULL_HANDLER,
67638
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67639
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67640
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67641
16
    ZEND_NULL_HANDLER,
67642
16
    ZEND_NULL_HANDLER,
67643
16
    ZEND_NULL_HANDLER,
67644
16
    ZEND_NULL_HANDLER,
67645
16
    ZEND_NULL_HANDLER,
67646
16
    ZEND_NULL_HANDLER,
67647
16
    ZEND_NULL_HANDLER,
67648
16
    ZEND_NULL_HANDLER,
67649
16
    ZEND_NULL_HANDLER,
67650
16
    ZEND_NULL_HANDLER,
67651
16
    ZEND_NULL_HANDLER,
67652
16
    ZEND_NULL_HANDLER,
67653
16
    ZEND_NULL_HANDLER,
67654
16
    ZEND_NULL_HANDLER,
67655
16
    ZEND_NULL_HANDLER,
67656
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67657
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67658
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67659
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67660
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67661
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67662
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67663
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67664
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67665
16
    ZEND_NULL_HANDLER,
67666
16
    ZEND_NULL_HANDLER,
67667
16
    ZEND_NULL_HANDLER,
67668
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67669
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67670
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67671
16
    ZEND_NULL_HANDLER,
67672
16
    ZEND_NULL_HANDLER,
67673
16
    ZEND_NULL_HANDLER,
67674
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67675
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67676
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67677
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67678
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67679
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67680
16
    ZEND_NULL_HANDLER,
67681
16
    ZEND_NULL_HANDLER,
67682
16
    ZEND_NULL_HANDLER,
67683
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67684
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67685
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67686
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67687
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67688
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67689
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67690
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67691
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67692
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67693
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67694
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67695
16
    ZEND_NULL_HANDLER,
67696
16
    ZEND_NULL_HANDLER,
67697
16
    ZEND_NULL_HANDLER,
67698
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67699
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67700
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67701
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67702
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67703
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67704
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67705
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67706
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67707
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67708
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67709
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67710
16
    ZEND_NULL_HANDLER,
67711
16
    ZEND_NULL_HANDLER,
67712
16
    ZEND_NULL_HANDLER,
67713
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67714
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67715
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67716
16
    ZEND_NULL_HANDLER,
67717
16
    ZEND_NULL_HANDLER,
67718
16
    ZEND_NULL_HANDLER,
67719
16
    ZEND_NULL_HANDLER,
67720
16
    ZEND_NULL_HANDLER,
67721
16
    ZEND_NULL_HANDLER,
67722
16
    ZEND_NULL_HANDLER,
67723
16
    ZEND_NULL_HANDLER,
67724
16
    ZEND_NULL_HANDLER,
67725
16
    ZEND_NULL_HANDLER,
67726
16
    ZEND_NULL_HANDLER,
67727
16
    ZEND_NULL_HANDLER,
67728
16
    ZEND_NULL_HANDLER,
67729
16
    ZEND_NULL_HANDLER,
67730
16
    ZEND_NULL_HANDLER,
67731
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67732
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67733
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67734
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67735
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67736
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67737
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67738
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67739
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67740
16
    ZEND_NULL_HANDLER,
67741
16
    ZEND_NULL_HANDLER,
67742
16
    ZEND_NULL_HANDLER,
67743
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67744
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67745
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67746
16
    ZEND_NULL_HANDLER,
67747
16
    ZEND_NULL_HANDLER,
67748
16
    ZEND_NULL_HANDLER,
67749
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67750
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67751
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67752
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67753
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67754
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67755
16
    ZEND_NULL_HANDLER,
67756
16
    ZEND_NULL_HANDLER,
67757
16
    ZEND_NULL_HANDLER,
67758
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67759
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67760
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67761
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67762
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67763
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67764
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67765
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67766
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67767
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67768
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67769
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67770
16
    ZEND_NULL_HANDLER,
67771
16
    ZEND_NULL_HANDLER,
67772
16
    ZEND_NULL_HANDLER,
67773
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67774
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67775
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67776
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67777
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67778
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67779
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67780
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67781
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67782
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67783
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67784
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67785
16
    ZEND_NULL_HANDLER,
67786
16
    ZEND_NULL_HANDLER,
67787
16
    ZEND_NULL_HANDLER,
67788
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67789
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67790
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67791
16
    ZEND_NULL_HANDLER,
67792
16
    ZEND_NULL_HANDLER,
67793
16
    ZEND_NULL_HANDLER,
67794
16
    ZEND_NULL_HANDLER,
67795
16
    ZEND_NULL_HANDLER,
67796
16
    ZEND_NULL_HANDLER,
67797
16
    ZEND_NULL_HANDLER,
67798
16
    ZEND_NULL_HANDLER,
67799
16
    ZEND_NULL_HANDLER,
67800
16
    ZEND_NULL_HANDLER,
67801
16
    ZEND_NULL_HANDLER,
67802
16
    ZEND_NULL_HANDLER,
67803
16
    ZEND_NULL_HANDLER,
67804
16
    ZEND_NULL_HANDLER,
67805
16
    ZEND_NULL_HANDLER,
67806
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67807
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67808
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67809
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67810
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67811
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67812
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67813
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67814
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67815
16
    ZEND_NULL_HANDLER,
67816
16
    ZEND_NULL_HANDLER,
67817
16
    ZEND_NULL_HANDLER,
67818
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67819
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67820
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67821
16
    ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
67822
16
    ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
67823
16
    ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
67824
16
    ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
67825
16
    ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
67826
16
    ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
67827
16
    ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
67828
16
    ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
67829
16
    ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
67830
16
    ZEND_POST_INC_LONG_SPEC_CV_HANDLER,
67831
16
    ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
67832
16
    ZEND_POST_DEC_LONG_SPEC_CV_HANDLER,
67833
16
    ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER,
67834
16
    ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67835
16
    ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67836
16
    ZEND_NULL_HANDLER,
67837
16
    ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67838
16
    ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER,
67839
16
    ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67840
16
    ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67841
16
    ZEND_NULL_HANDLER,
67842
16
    ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67843
16
    ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER,
67844
16
    ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67845
16
    ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67846
16
    ZEND_NULL_HANDLER,
67847
16
    ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67848
16
    ZEND_NULL_HANDLER,
67849
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67850
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67851
16
    ZEND_NULL_HANDLER,
67852
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67853
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
67854
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67855
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67856
16
    ZEND_NULL_HANDLER,
67857
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67858
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
67859
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67860
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67861
16
    ZEND_NULL_HANDLER,
67862
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67863
16
    ZEND_NULL_HANDLER,
67864
16
    ZEND_NULL_HANDLER,
67865
16
    ZEND_NULL_HANDLER,
67866
16
    ZEND_NULL_HANDLER,
67867
16
    ZEND_NULL_HANDLER,
67868
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER,
67869
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67870
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67871
16
    ZEND_NULL_HANDLER,
67872
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67873
16
    ZEND_NULL_HANDLER,
67874
16
    ZEND_NULL_HANDLER,
67875
16
    ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER,
67876
16
    ZEND_NULL_HANDLER,
67877
16
    ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER,
67878
16
    ZEND_NULL_HANDLER,
67879
16
    ZEND_NULL_HANDLER,
67880
16
    ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER,
67881
16
    ZEND_NULL_HANDLER,
67882
16
    ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER,
67883
16
    ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER,
67884
16
    ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER,
67885
16
    ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
67886
16
    ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER,
67887
16
    ZEND_NULL_HANDLER
67888
16
  };
67889
16
  static const uint32_t specs[] = {
67890
16
    0,
67891
16
    1 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67892
16
    26 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67893
16
    51 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67894
16
    76 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67895
16
    101 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67896
16
    126 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67897
16
    151 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67898
16
    176 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67899
16
    201 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67900
16
    226 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67901
16
    251 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67902
16
    276 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67903
16
    301 | SPEC_RULE_OP1,
67904
16
    306 | SPEC_RULE_OP1,
67905
16
    311 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67906
16
    336 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67907
16
    361 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67908
16
    386 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
67909
16
    461 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
67910
16
    536 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
67911
16
    611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
67912
16
    686 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL,
67913
16
    736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67914
16
    861 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67915
16
    986 | SPEC_RULE_OP_DATA,
67916
16
    991 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67917
16
    1016 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67918
16
    1041 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67919
16
    1066,
67920
16
    1067 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67921
16
    1092 | SPEC_RULE_OP1,
67922
16
    1097 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67923
16
    1222,
67924
16
    1223 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
67925
16
    1233 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
67926
16
    1243 | SPEC_RULE_OP1,
67927
16
    1248 | SPEC_RULE_OP1,
67928
16
    1253,
67929
16
    1253,
67930
16
    1254,
67931
16
    1254,
67932
16
    1255,
67933
16
    1256 | SPEC_RULE_OP1,
67934
16
    1261 | SPEC_RULE_OP1,
67935
16
    3493,
67936
16
    1266 | SPEC_RULE_OP1,
67937
16
    1271 | SPEC_RULE_OP1,
67938
16
    1276 | SPEC_RULE_OP2,
67939
16
    1281,
67940
16
    1282 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67941
16
    1292 | SPEC_RULE_OP1,
67942
16
    1297 | SPEC_RULE_OP1,
67943
16
    1302 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67944
16
    1327 | SPEC_RULE_OP2,
67945
16
    1332 | SPEC_RULE_OP2,
67946
16
    1337 | SPEC_RULE_OP2,
67947
16
    1342,
67948
16
    1343,
67949
16
    1344,
67950
16
    1345 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67951
16
    1349,
67952
16
    1350 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67953
16
    1360,
67954
16
    1361,
67955
16
    1362 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67956
16
    1387 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67957
16
    1437 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67958
16
    1462 | SPEC_RULE_OP1,
67959
16
    1467,
67960
16
    1468,
67961
16
    1469 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67962
16
    1494 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67963
16
    1519 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67964
16
    1529 | SPEC_RULE_OP1,
67965
16
    1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67966
16
    1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67967
16
    1584 | SPEC_RULE_OP1,
67968
16
    1589,
67969
16
    3493,
67970
16
    1590 | SPEC_RULE_OP1,
67971
16
    1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67972
16
    1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67973
16
    1645 | SPEC_RULE_OP1,
67974
16
    1650 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67975
16
    1675 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67976
16
    1700 | SPEC_RULE_OP1,
67977
16
    1705 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67978
16
    1730 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67979
16
    1755 | SPEC_RULE_OP1,
67980
16
    1760 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67981
16
    1785 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67982
16
    1810 | SPEC_RULE_OP1,
67983
16
    1815 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67984
16
    1840 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67985
16
    1865 | SPEC_RULE_OP1,
67986
16
    1870 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67987
16
    1895 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67988
16
    1920 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67989
16
    1945,
67990
16
    1946 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67991
16
    1956,
67992
16
    1957,
67993
16
    1958,
67994
16
    1959,
67995
16
    1960,
67996
16
    1961 | SPEC_RULE_OP2,
67997
16
    1966,
67998
16
    1967 | SPEC_RULE_OP1,
67999
16
    1972 | SPEC_RULE_OP2,
68000
16
    1977 | SPEC_RULE_OP1,
68001
16
    1982 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
68002
16
    1992 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68003
16
    2017 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68004
16
    2042 | SPEC_RULE_OP1,
68005
16
    2047 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68006
16
    2072 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
68007
16
    2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68008
16
    2147 | SPEC_RULE_OP2,
68009
16
    2152,
68010
16
    2153 | SPEC_RULE_OP1,
68011
16
    2158 | SPEC_RULE_OP1,
68012
16
    2163,
68013
16
    2164 | SPEC_RULE_OP1,
68014
16
    2169 | SPEC_RULE_OP1,
68015
16
    2174 | SPEC_RULE_OP1,
68016
16
    2179,
68017
16
    2180,
68018
16
    2181 | SPEC_RULE_OP2,
68019
16
    2186 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
68020
16
    2190 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
68021
16
    2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
68022
16
    2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68023
16
    2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68024
16
    2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68025
16
    2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68026
16
    2248 | SPEC_RULE_OP1,
68027
16
    2253,
68028
16
    2254 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68029
16
    2279,
68030
16
    2280 | SPEC_RULE_OP1,
68031
16
    2285,
68032
16
    2286,
68033
16
    2287,
68034
16
    2288,
68035
16
    2289,
68036
16
    2290,
68037
16
    2291,
68038
16
    2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68039
16
    2317,
68040
16
    2318,
68041
16
    2319,
68042
16
    2320 | SPEC_RULE_OP1,
68043
16
    2325,
68044
16
    2326 | SPEC_RULE_ISSET,
68045
16
    2328 | SPEC_RULE_OP2,
68046
16
    2333,
68047
16
    2334 | SPEC_RULE_OP1,
68048
16
    2339 | SPEC_RULE_OBSERVER,
68049
16
    2341,
68050
16
    2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68051
16
    2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
68052
16
    2377,
68053
16
    2378,
68054
16
    2379,
68055
16
    2380,
68056
16
    2381 | SPEC_RULE_OP1,
68057
16
    2386,
68058
16
    2387,
68059
16
    2388 | SPEC_RULE_OP1,
68060
16
    2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68061
16
    2418,
68062
16
    2419 | SPEC_RULE_OP1,
68063
16
    2424,
68064
16
    2425,
68065
16
    2426,
68066
16
    2427,
68067
16
    2428,
68068
16
    2429,
68069
16
    2430,
68070
16
    2431,
68071
16
    2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68072
16
    2457,
68073
16
    2458,
68074
16
    2459,
68075
16
    2460 | SPEC_RULE_OP2,
68076
16
    2465,
68077
16
    2466 | SPEC_RULE_OP1,
68078
16
    2471 | SPEC_RULE_OP1,
68079
16
    2476 | SPEC_RULE_OP1,
68080
16
    2481 | SPEC_RULE_OP1,
68081
16
    2486 | SPEC_RULE_OP1,
68082
16
    2491,
68083
16
    2492 | SPEC_RULE_OP1,
68084
16
    2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68085
16
    2522 | SPEC_RULE_OP1,
68086
16
    2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68087
16
    2552 | SPEC_RULE_OP1,
68088
16
    2557 | SPEC_RULE_OP1,
68089
16
    2562,
68090
16
    2563,
68091
16
    2564,
68092
16
    2565,
68093
16
    2566,
68094
16
    2567 | SPEC_RULE_OBSERVER,
68095
16
    2569 | SPEC_RULE_OBSERVER,
68096
16
    2571 | SPEC_RULE_OBSERVER,
68097
16
    2573 | SPEC_RULE_OBSERVER,
68098
16
    2575,
68099
16
    2576,
68100
16
    2577,
68101
16
    3493,
68102
16
    3493,
68103
16
    3493,
68104
16
    3493,
68105
16
    3493,
68106
16
    3493,
68107
16
    3493,
68108
16
    3493,
68109
16
    3493,
68110
16
    3493,
68111
16
    3493,
68112
16
    3493,
68113
16
    3493,
68114
16
    3493,
68115
16
    3493,
68116
16
    3493,
68117
16
    3493,
68118
16
    3493,
68119
16
    3493,
68120
16
    3493,
68121
16
    3493,
68122
16
    3493,
68123
16
    3493,
68124
16
    3493,
68125
16
    3493,
68126
16
    3493,
68127
16
    3493,
68128
16
    3493,
68129
16
    3493,
68130
16
    3493,
68131
16
    3493,
68132
16
    3493,
68133
16
    3493,
68134
16
    3493,
68135
16
    3493,
68136
16
    3493,
68137
16
    3493,
68138
16
    3493,
68139
16
    3493,
68140
16
    3493,
68141
16
    3493,
68142
16
    3493,
68143
16
    3493,
68144
16
    3493,
68145
16
    3493,
68146
16
  };
68147
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68148
  zend_opcode_handler_funcs = labels;
68149
  zend_spec_handlers = specs;
68150
  execute_ex(NULL);
68151
#else
68152
16
  zend_opcode_handlers = labels;
68153
16
  zend_handlers_count = sizeof(labels) / sizeof(void*);
68154
16
  zend_spec_handlers = specs;
68155
16
#endif
68156
16
  VM_TRACE_START();
68157
16
}
68158
68159
static HashTable *zend_handlers_table = NULL;
68160
68161
void zend_vm_dtor(void)
68162
0
{
68163
0
  VM_TRACE_END();
68164
0
  if (zend_handlers_table) {
68165
0
    zend_hash_destroy(zend_handlers_table);
68166
0
    free(zend_handlers_table);
68167
0
    zend_handlers_table = NULL;
68168
0
  }
68169
0
}
68170
68171
static void init_opcode_serialiser(void)
68172
0
{
68173
0
  int i;
68174
0
  zval tmp;
68175
68176
0
  zend_handlers_table = malloc(sizeof(HashTable));
68177
0
  zend_hash_init(zend_handlers_table, zend_handlers_count, NULL, NULL, 1);
68178
0
  zend_hash_real_init(zend_handlers_table, 0);
68179
0
  Z_TYPE_INFO(tmp) = IS_LONG;
68180
0
  for (i = 0; i < zend_handlers_count; i++) {
68181
0
    Z_LVAL(tmp) = i;
68182
0
    zend_hash_index_add(zend_handlers_table, (zend_long)(uintptr_t)zend_opcode_handlers[i], &tmp);
68183
0
  }
68184
0
}
68185
68186
ZEND_API void ZEND_FASTCALL zend_serialize_opcode_handler(zend_op *op)
68187
0
{
68188
0
  zval *zv;
68189
68190
0
  if (!zend_handlers_table) {
68191
0
    init_opcode_serialiser();
68192
0
  }
68193
0
  zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
68194
0
  ZEND_ASSERT(zv != NULL);
68195
0
  op->handler = (const void *)(uintptr_t)Z_LVAL_P(zv);
68196
0
}
68197
68198
ZEND_API void ZEND_FASTCALL zend_deserialize_opcode_handler(zend_op *op)
68199
0
{
68200
0
  op->handler = zend_opcode_handlers[(uintptr_t)op->handler];
68201
0
}
68202
68203
ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *op)
68204
0
{
68205
0
#if ZEND_VM_KIND == ZEND_VM_KIND_CALL
68206
0
  return op->handler;
68207
#elif ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68208
  zval *zv;
68209
68210
  if (!zend_handlers_table) {
68211
    init_opcode_serialiser();
68212
  }
68213
  zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
68214
  ZEND_ASSERT(zv != NULL);
68215
  return zend_opcode_handler_funcs[Z_LVAL_P(zv)];
68216
#else
68217
  return NULL;
68218
#endif
68219
0
}
68220
68221
ZEND_API const zend_op *zend_get_halt_op(void)
68222
0
{
68223
#if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68224
  return &hybrid_halt_op;
68225
#else
68226
0
  return NULL;
68227
0
#endif
68228
0
}
68229
68230
ZEND_API int zend_vm_kind(void)
68231
0
{
68232
0
  return ZEND_VM_KIND;
68233
0
}
68234
68235
static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, const zend_op* op)
68236
9.19M
{
68237
9.19M
  static const int zend_vm_decode[] = {
68238
9.19M
    _UNUSED_CODE, /* 0 = IS_UNUSED  */
68239
9.19M
    _CONST_CODE,  /* 1 = IS_CONST   */
68240
9.19M
    _TMP_CODE,    /* 2 = IS_TMP_VAR */
68241
9.19M
    _UNUSED_CODE, /* 3              */
68242
9.19M
    _VAR_CODE,    /* 4 = IS_VAR     */
68243
9.19M
    _UNUSED_CODE, /* 5              */
68244
9.19M
    _UNUSED_CODE, /* 6              */
68245
9.19M
    _UNUSED_CODE, /* 7              */
68246
9.19M
    _CV_CODE      /* 8 = IS_CV      */
68247
9.19M
  };
68248
9.19M
  uint32_t offset = 0;
68249
9.19M
  if (spec & SPEC_RULE_OP1) offset = offset * 5 + zend_vm_decode[op->op1_type];
68250
9.19M
  if (spec & SPEC_RULE_OP2) offset = offset * 5 + zend_vm_decode[op->op2_type];
68251
9.19M
  if (spec & SPEC_EXTRA_MASK) {
68252
1.96M
    if (spec & SPEC_RULE_RETVAL) {
68253
1.07M
      offset = offset * 2 + (op->result_type != IS_UNUSED);
68254
1.07M
      if ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {
68255
0
        offset += 2;
68256
0
      }
68257
1.07M
    } else if (spec & SPEC_RULE_QUICK_ARG) {
68258
298k
      offset = offset * 2 + (op->op2.num <= MAX_ARG_FLAG_NUM);
68259
592k
    } else if (spec & SPEC_RULE_OP_DATA) {
68260
52.5k
      offset = offset * 5 + zend_vm_decode[(op + 1)->op1_type];
68261
540k
    } else if (spec & SPEC_RULE_ISSET) {
68262
1.23k
      offset = offset * 2 + (op->extended_value & ZEND_ISEMPTY);
68263
539k
    } else if (spec & SPEC_RULE_SMART_BRANCH) {
68264
71.8k
      offset = offset * 3;
68265
71.8k
      if (op->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR)) {
68266
30.4k
        offset += 1;
68267
41.3k
      } else if (op->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) {
68268
14.5k
        offset += 2;
68269
14.5k
      }
68270
467k
    } else if (spec & SPEC_RULE_OBSERVER) {
68271
370k
      offset = offset * 2;
68272
370k
      if (ZEND_OBSERVER_ENABLED) {
68273
0
        offset += 1;
68274
0
      }
68275
370k
    }
68276
1.96M
  }
68277
9.19M
  return (spec & SPEC_START_MASK) + offset;
68278
9.19M
}
68279
68280
#if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
68281
static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op)
68282
0
{
68283
0
  return zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
68284
0
}
68285
#endif
68286
68287
#if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68288
static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op* op)
68289
{
68290
  uint32_t spec = zend_spec_handlers[opcode];
68291
  return zend_opcode_handler_funcs[zend_vm_get_opcode_handler_idx(spec, op)];
68292
}
68293
68294
#endif
68295
68296
ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler(zend_op* op)
68297
7.80M
{
68298
7.80M
  uint8_t opcode = zend_user_opcodes[op->opcode];
68299
68300
7.80M
  if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
68301
119k
    if (op->op1_type < op->op2_type) {
68302
9.68k
      zend_swap_operands(op);
68303
9.68k
    }
68304
119k
  }
68305
7.80M
  op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
68306
7.80M
}
68307
68308
ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint32_t op2_info, uint32_t res_info)
68309
1.39M
{
68310
1.39M
  uint8_t opcode = zend_user_opcodes[op->opcode];
68311
1.39M
  uint32_t spec = zend_spec_handlers[opcode];
68312
1.39M
  switch (opcode) {
68313
9.66k
    case ZEND_ADD:
68314
9.66k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68315
140
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68316
4
          break;
68317
4
        }
68318
136
        spec = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68319
136
        if (op->op1_type < op->op2_type) {
68320
15
          zend_swap_operands(op);
68321
15
        }
68322
9.52k
      } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68323
277
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68324
0
          break;
68325
0
        }
68326
277
        spec = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68327
277
        if (op->op1_type < op->op2_type) {
68328
29
          zend_swap_operands(op);
68329
29
        }
68330
9.25k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68331
75
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68332
0
          break;
68333
0
        }
68334
75
        spec = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68335
75
        if (op->op1_type < op->op2_type) {
68336
0
          zend_swap_operands(op);
68337
0
        }
68338
75
      }
68339
9.66k
      break;
68340
9.66k
    case ZEND_SUB:
68341
3.22k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68342
252
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68343
0
          break;
68344
0
        }
68345
252
        spec = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68346
2.97k
      } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68347
139
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68348
0
          break;
68349
0
        }
68350
139
        spec = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68351
2.83k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68352
10
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68353
0
          break;
68354
0
        }
68355
10
        spec = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68356
10
      }
68357
3.22k
      break;
68358
4.92k
    case ZEND_MUL:
68359
4.92k
      if (op->op1_type < op->op2_type) {
68360
7
        zend_swap_operands(op);
68361
7
      }
68362
4.92k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68363
25
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68364
0
          break;
68365
0
        }
68366
25
        spec = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68367
4.89k
      } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68368
204
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68369
0
          break;
68370
0
        }
68371
204
        spec = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68372
4.69k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68373
20
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68374
0
          break;
68375
0
        }
68376
20
        spec = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68377
20
      }
68378
4.92k
      break;
68379
4.92k
    case ZEND_IS_IDENTICAL:
68380
1.39k
      if (op->op1_type < op->op2_type) {
68381
6
        zend_swap_operands(op);
68382
6
      }
68383
1.39k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68384
144
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68385
0
          break;
68386
0
        }
68387
144
        spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68388
1.25k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68389
62
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68390
0
          break;
68391
0
        }
68392
62
        spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68393
1.18k
      } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) {
68394
0
        spec = 3111 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68395
1.18k
      } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) {
68396
219
        spec = 3117 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68397
219
      }
68398
1.39k
      break;
68399
1.39k
    case ZEND_IS_NOT_IDENTICAL:
68400
419
      if (op->op1_type < op->op2_type) {
68401
28
        zend_swap_operands(op);
68402
28
      }
68403
419
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68404
10
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68405
0
          break;
68406
0
        }
68407
10
        spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68408
409
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68409
48
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68410
0
          break;
68411
0
        }
68412
48
        spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68413
361
      } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) {
68414
0
        spec = 3114 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68415
361
      } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) {
68416
20
        spec = 3122 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68417
20
      }
68418
419
      break;
68419
2.60k
    case ZEND_IS_EQUAL:
68420
2.60k
      if (op->op1_type < op->op2_type) {
68421
13
        zend_swap_operands(op);
68422
13
      }
68423
2.60k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68424
136
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68425
0
          break;
68426
0
        }
68427
136
        spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68428
2.46k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68429
118
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68430
0
          break;
68431
0
        }
68432
118
        spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68433
118
      }
68434
2.60k
      break;
68435
2.60k
    case ZEND_IS_NOT_EQUAL:
68436
1.64k
      if (op->op1_type < op->op2_type) {
68437
60
        zend_swap_operands(op);
68438
60
      }
68439
1.64k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68440
10
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68441
0
          break;
68442
0
        }
68443
10
        spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68444
1.63k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68445
74
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68446
0
          break;
68447
0
        }
68448
74
        spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68449
74
      }
68450
1.64k
      break;
68451
5.85k
    case ZEND_IS_SMALLER:
68452
5.85k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68453
987
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68454
4
          break;
68455
4
        }
68456
983
        spec = 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68457
4.86k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68458
39
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68459
0
          break;
68460
0
        }
68461
39
        spec = 3202 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68462
39
      }
68463
5.84k
      break;
68464
5.84k
    case ZEND_IS_SMALLER_OR_EQUAL:
68465
1.76k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68466
329
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68467
0
          break;
68468
0
        }
68469
329
        spec = 3277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68470
1.43k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68471
0
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68472
0
          break;
68473
0
        }
68474
0
        spec = 3352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68475
0
      }
68476
1.76k
      break;
68477
17.6k
    case ZEND_QM_ASSIGN:
68478
17.6k
      if (op1_info == MAY_BE_LONG) {
68479
3.58k
        spec = 3439 | SPEC_RULE_OP1;
68480
14.0k
      } else if (op1_info == MAY_BE_DOUBLE) {
68481
92
        spec = 3444 | SPEC_RULE_OP1;
68482
13.9k
      } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) {
68483
9.97k
        spec = 3449 | SPEC_RULE_OP1;
68484
9.97k
      }
68485
17.6k
      break;
68486
3.76k
    case ZEND_PRE_INC:
68487
3.76k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68488
879
        spec = 3427 | SPEC_RULE_RETVAL;
68489
2.88k
      } else if (op1_info == MAY_BE_LONG) {
68490
12
        spec = 3429 | SPEC_RULE_RETVAL;
68491
12
      }
68492
3.76k
      break;
68493
505
    case ZEND_PRE_DEC:
68494
505
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68495
16
        spec = 3431 | SPEC_RULE_RETVAL;
68496
489
      } else if (op1_info == MAY_BE_LONG) {
68497
34
        spec = 3433 | SPEC_RULE_RETVAL;
68498
34
      }
68499
505
      break;
68500
732
    case ZEND_POST_INC:
68501
732
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68502
66
        spec = 3435;
68503
666
      } else if (op1_info == MAY_BE_LONG) {
68504
6
        spec = 3436;
68505
6
      }
68506
732
      break;
68507
1.19k
    case ZEND_POST_DEC:
68508
1.19k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68509
5
        spec = 3437;
68510
1.19k
      } else if (op1_info == MAY_BE_LONG) {
68511
48
        spec = 3438;
68512
48
      }
68513
1.19k
      break;
68514
12.1k
    case ZEND_JMP:
68515
12.1k
      if (OP_JMP_ADDR(op, op->op1) > op) {
68516
7.87k
        spec = 2585;
68517
7.87k
      }
68518
12.1k
      break;
68519
75.4k
    case ZEND_INIT_FCALL:
68520
75.4k
      if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) {
68521
58.3k
        spec = 2578;
68522
58.3k
      }
68523
75.4k
      break;
68524
20.2k
    case ZEND_RECV:
68525
20.2k
      if (op->op2.num == MAY_BE_ANY) {
68526
15.0k
        spec = 2579;
68527
15.0k
      }
68528
20.2k
      break;
68529
98.4k
    case ZEND_SEND_VAL:
68530
98.4k
      if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
68531
70.9k
        spec = 3489;
68532
70.9k
      }
68533
98.4k
      break;
68534
6.20k
    case ZEND_SEND_VAR_EX:
68535
6.20k
      if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
68536
1.48k
        spec = 3484 | SPEC_RULE_OP1;
68537
1.48k
      }
68538
6.20k
      break;
68539
2.59k
    case ZEND_FE_FETCH_R:
68540
2.59k
      if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
68541
503
        spec = 3491 | SPEC_RULE_RETVAL;
68542
503
      }
68543
2.59k
      break;
68544
6.72k
    case ZEND_FETCH_DIM_R:
68545
6.72k
      if (!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
68546
3.61k
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68547
116
          break;
68548
116
        }
68549
3.50k
        spec = 3454 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68550
3.50k
      }
68551
6.60k
      break;
68552
38.8k
    case ZEND_SEND_VAL_EX:
68553
38.8k
      if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
68554
30.8k
        spec = 3490;
68555
30.8k
      }
68556
38.8k
      break;
68557
32.1k
    case ZEND_SEND_VAR:
68558
32.1k
      if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
68559
14.7k
        spec = 3479 | SPEC_RULE_OP1;
68560
14.7k
      }
68561
32.1k
      break;
68562
410
    case ZEND_COUNT:
68563
410
      if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
68564
142
        spec = 2580 | SPEC_RULE_OP1;
68565
142
      }
68566
410
      break;
68567
539
    case ZEND_BW_OR:
68568
4.06k
    case ZEND_BW_AND:
68569
6.02k
    case ZEND_BW_XOR:
68570
6.11k
    case ZEND_BOOL_XOR:
68571
6.11k
      if (op->op1_type < op->op2_type) {
68572
208
        zend_swap_operands(op);
68573
208
      }
68574
6.11k
      break;
68575
0
    case ZEND_USER_OPCODE:
68576
0
      if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
68577
0
        if (op->op1_type < op->op2_type) {
68578
0
          zend_swap_operands(op);
68579
0
        }
68580
0
      }
68581
0
      break;
68582
1.03M
    default:
68583
1.03M
      break;
68584
1.39M
  }
68585
1.39M
  op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(spec, op)];
68586
1.39M
}
68587
68588
ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex)
68589
0
{
68590
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68591
  opcode_handler_t handler;
68592
#endif
68593
0
  DCL_OPLINE;
68594
0
  int ret;
68595
#ifdef ZEND_VM_IP_GLOBAL_REG
68596
  const zend_op *orig_opline = opline;
68597
#endif
68598
#ifdef ZEND_VM_FP_GLOBAL_REG
68599
  zend_execute_data *orig_execute_data = execute_data;
68600
  execute_data = ex;
68601
#else
68602
0
  zend_execute_data *execute_data = ex;
68603
0
#endif
68604
68605
0
  LOAD_OPLINE();
68606
#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
68607
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68608
  handler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[opline->opcode], opline);
68609
  handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68610
  if (EXPECTED(opline != &hybrid_halt_op)) {
68611
#else
68612
  ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68613
  if (EXPECTED(opline)) {
68614
#endif
68615
    ret = execute_data != ex ? (int)(execute_data->prev_execute_data != ex) + 1 : 0;
68616
    SAVE_OPLINE();
68617
  } else {
68618
    ret = -1;
68619
  }
68620
#else
68621
0
  opline = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68622
0
if (UNEXPECTED(((uintptr_t)opline & ZEND_VM_ENTER_BIT))) {
68623
0
    opline = (const zend_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT);
68624
0
    if (EXPECTED(opline)) {
68625
      /* ZEND_VM_ENTER() or ZEND_VM_LEAVE() */
68626
0
      ret = EG(current_execute_data) != ex ? (int)(EG(current_execute_data)->prev_execute_data != ex) + 1 : 0;
68627
0
      execute_data = EG(current_execute_data);
68628
0
      SAVE_OPLINE();
68629
0
    } else {
68630
      /* ZEND_VM_RETURN() */
68631
0
      ret = -1;
68632
0
    }
68633
0
  } else {
68634
    /* ZEND_VM_CONTINUE() */
68635
0
    SAVE_OPLINE();
68636
0
    ret = 0;
68637
0
  }
68638
0
#endif
68639
#ifdef ZEND_VM_FP_GLOBAL_REG
68640
  execute_data = orig_execute_data;
68641
#endif
68642
#ifdef ZEND_VM_IP_GLOBAL_REG
68643
  opline = orig_opline;
68644
#endif
68645
0
  return ret;
68646
0
}
68647