Coverage Report

Created: 2025-07-23 06:33

/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
13.5M
#define SPEC_START_MASK        0x0000ffff
312
13.5M
#define SPEC_EXTRA_MASK        0xfffc0000
313
13.5M
#define SPEC_RULE_OP1          0x00010000
314
13.5M
#define SPEC_RULE_OP2          0x00020000
315
846k
#define SPEC_RULE_OP_DATA      0x00040000
316
2.61M
#define SPEC_RULE_RETVAL       0x00080000
317
1.36M
#define SPEC_RULE_QUICK_ARG    0x00100000
318
792k
#define SPEC_RULE_SMART_BRANCH 0x00200000
319
11.7M
#define SPEC_RULE_COMMUTATIVE  0x00800000
320
791k
#define SPEC_RULE_ISSET        0x01000000
321
1.86M
#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.61M
# 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.10M
# define ZEND_VM_TAIL_CALL(call) return call
401
16.6M
# define ZEND_VM_CONTINUE()      return opline
402
397k
# 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
82.6k
# define DCL_OPLINE const zend_op *opline;
420
15.8M
# define OPLINE opline
421
# define USE_OPLINE
422
964k
# define LOAD_OPLINE() opline = EX(opline)
423
29.1k
# define LOAD_OPLINE_EX() opline = EX(opline)
424
25.7k
# define LOAD_NEXT_OPLINE() opline = EX(opline) + 1
425
11.7M
# define SAVE_OPLINE() EX(opline) = opline
426
# define SAVE_OPLINE_EX()
427
#endif
428
832k
#define HANDLE_EXCEPTION() ZEND_ASSERT(EG(exception)); LOAD_OPLINE(); ZEND_VM_CONTINUE()
429
3.68k
#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
572k
# define ZEND_VM_ENTER_BIT         1ULL
440
30.2k
# define ZEND_VM_ENTER_EX()        return (zend_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT)
441
1.05k
# define ZEND_VM_ENTER()           execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX()
442
31.0k
# 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
40.2k
{
453
40.2k
  USE_OPLINE
454
455
40.2k
  SAVE_OPLINE();
456
40.2k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
457
7.99k
    op_1 = ZVAL_UNDEFINED_OP1();
458
7.99k
  }
459
40.2k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
460
12.3k
    op_2 = ZVAL_UNDEFINED_OP2();
461
12.3k
  }
462
40.2k
  add_function(EX_VAR(opline->result.var), op_1, op_2);
463
40.2k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
464
16.4k
    zval_ptr_dtor_nogc(op_1);
465
16.4k
  }
466
40.2k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
467
12.3k
    zval_ptr_dtor_nogc(op_2);
468
12.3k
  }
469
40.2k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
470
40.2k
}
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
8.51k
{
474
8.51k
  USE_OPLINE
475
476
8.51k
  SAVE_OPLINE();
477
8.51k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
478
979
    op_1 = ZVAL_UNDEFINED_OP1();
479
979
  }
480
8.51k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
481
1.72k
    op_2 = ZVAL_UNDEFINED_OP2();
482
1.72k
  }
483
8.51k
  sub_function(EX_VAR(opline->result.var), op_1, op_2);
484
8.51k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
485
1.68k
    zval_ptr_dtor_nogc(op_1);
486
1.68k
  }
487
8.51k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
488
1.94k
    zval_ptr_dtor_nogc(op_2);
489
1.94k
  }
490
8.51k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
491
8.51k
}
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
42.3k
{
495
42.3k
  USE_OPLINE
496
497
42.3k
  SAVE_OPLINE();
498
42.3k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
499
27.8k
    op_1 = ZVAL_UNDEFINED_OP1();
500
27.8k
  }
501
42.3k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
502
900
    op_2 = ZVAL_UNDEFINED_OP2();
503
900
  }
504
42.3k
  mul_function(EX_VAR(opline->result.var), op_1, op_2);
505
42.3k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
506
3.08k
    zval_ptr_dtor_nogc(op_1);
507
3.08k
  }
508
42.3k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
509
939
    zval_ptr_dtor_nogc(op_2);
510
939
  }
511
42.3k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
512
42.3k
}
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
60
{
516
60
  USE_OPLINE
517
518
60
  SAVE_OPLINE();
519
60
  zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero");
520
60
  ZVAL_UNDEF(EX_VAR(opline->result.var));
521
60
  HANDLE_EXCEPTION();
522
60
}
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
20.7k
{
526
20.7k
  USE_OPLINE
527
528
20.7k
  SAVE_OPLINE();
529
20.7k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
530
912
    op_1 = ZVAL_UNDEFINED_OP1();
531
912
  }
532
20.7k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
533
8
    op_2 = ZVAL_UNDEFINED_OP2();
534
8
  }
535
20.7k
  mod_function(EX_VAR(opline->result.var), op_1, op_2);
536
20.7k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
537
386
    zval_ptr_dtor_nogc(op_1);
538
386
  }
539
20.7k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
540
1.02k
    zval_ptr_dtor_nogc(op_2);
541
1.02k
  }
542
20.7k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
543
20.7k
}
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
3.75k
{
547
3.75k
  USE_OPLINE
548
549
3.75k
  SAVE_OPLINE();
550
3.75k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
551
33
    op_1 = ZVAL_UNDEFINED_OP1();
552
33
  }
553
3.75k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
554
120
    op_2 = ZVAL_UNDEFINED_OP2();
555
120
  }
556
3.75k
  shift_left_function(EX_VAR(opline->result.var), op_1, op_2);
557
3.75k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
558
229
    zval_ptr_dtor_nogc(op_1);
559
229
  }
560
3.75k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
561
91
    zval_ptr_dtor_nogc(op_2);
562
91
  }
563
3.75k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
564
3.75k
}
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
1.25k
{
568
1.25k
  USE_OPLINE
569
570
1.25k
  SAVE_OPLINE();
571
1.25k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
572
249
    op_1 = ZVAL_UNDEFINED_OP1();
573
249
  }
574
1.25k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
575
0
    op_2 = ZVAL_UNDEFINED_OP2();
576
0
  }
577
1.25k
  shift_right_function(EX_VAR(opline->result.var), op_1, op_2);
578
1.25k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
579
106
    zval_ptr_dtor_nogc(op_1);
580
106
  }
581
1.25k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
582
544
    zval_ptr_dtor_nogc(op_2);
583
544
  }
584
1.25k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
585
1.25k
}
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
218k
{
589
218k
  int ret;
590
218k
  USE_OPLINE
591
592
218k
  SAVE_OPLINE();
593
218k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
594
211k
    op_1 = ZVAL_UNDEFINED_OP1();
595
211k
  }
596
218k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
597
263
    op_2 = ZVAL_UNDEFINED_OP2();
598
263
  }
599
218k
  ret = zend_compare(op_1, op_2);
600
218k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
601
656
    zval_ptr_dtor_nogc(op_1);
602
656
  }
603
218k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
604
3.84k
    zval_ptr_dtor_nogc(op_2);
605
3.84k
  }
606
218k
  ZEND_VM_SMART_BRANCH(ret == 0, 1);
607
218k
}
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
17.5k
{
611
17.5k
  int ret;
612
17.5k
  USE_OPLINE
613
614
17.5k
  SAVE_OPLINE();
615
17.5k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
616
10.5k
    op_1 = ZVAL_UNDEFINED_OP1();
617
10.5k
  }
618
17.5k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
619
1.46k
    op_2 = ZVAL_UNDEFINED_OP2();
620
1.46k
  }
621
17.5k
  ret = zend_compare(op_1, op_2);
622
17.5k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
623
1.05k
    zval_ptr_dtor_nogc(op_1);
624
1.05k
  }
625
17.5k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
626
8.92k
    zval_ptr_dtor_nogc(op_2);
627
8.92k
  }
628
17.5k
  ZEND_VM_SMART_BRANCH(ret != 0, 1);
629
17.5k
}
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
46.8k
{
633
46.8k
  int ret;
634
46.8k
  USE_OPLINE
635
636
46.8k
  SAVE_OPLINE();
637
46.8k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
638
18.0k
    op_1 = ZVAL_UNDEFINED_OP1();
639
18.0k
  }
640
46.8k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
641
24.1k
    op_2 = ZVAL_UNDEFINED_OP2();
642
24.1k
  }
643
46.8k
  ret = zend_compare(op_1, op_2);
644
46.8k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
645
24.9k
    zval_ptr_dtor_nogc(op_1);
646
24.9k
  }
647
46.8k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
648
2.44k
    zval_ptr_dtor_nogc(op_2);
649
2.44k
  }
650
46.8k
  ZEND_VM_SMART_BRANCH(ret < 0, 1);
651
46.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
25.6k
{
655
25.6k
  int ret;
656
25.6k
  USE_OPLINE
657
658
25.6k
  SAVE_OPLINE();
659
25.6k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
660
3.82k
    op_1 = ZVAL_UNDEFINED_OP1();
661
3.82k
  }
662
25.6k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
663
18.0k
    op_2 = ZVAL_UNDEFINED_OP2();
664
18.0k
  }
665
25.6k
  ret = zend_compare(op_1, op_2);
666
25.6k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
667
17.4k
    zval_ptr_dtor_nogc(op_1);
668
17.4k
  }
669
25.6k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
670
601
    zval_ptr_dtor_nogc(op_2);
671
601
  }
672
25.6k
  ZEND_VM_SMART_BRANCH(ret <= 0, 1);
673
25.6k
}
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
8.11k
{
677
8.11k
  USE_OPLINE
678
679
8.11k
  SAVE_OPLINE();
680
8.11k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
681
19
    op_1 = ZVAL_UNDEFINED_OP1();
682
19
  }
683
8.11k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
684
12
    op_2 = ZVAL_UNDEFINED_OP2();
685
12
  }
686
8.11k
  bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2);
687
8.11k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
688
6.56k
    zval_ptr_dtor_nogc(op_1);
689
6.56k
  }
690
8.11k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
691
1.73k
    zval_ptr_dtor_nogc(op_2);
692
1.73k
  }
693
8.11k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
694
8.11k
}
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
114k
{
698
114k
  USE_OPLINE
699
700
114k
  SAVE_OPLINE();
701
114k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
702
1.18k
    op_1 = ZVAL_UNDEFINED_OP1();
703
1.18k
  }
704
114k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
705
868
    op_2 = ZVAL_UNDEFINED_OP2();
706
868
  }
707
114k
  bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2);
708
114k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
709
52.5k
    zval_ptr_dtor_nogc(op_1);
710
52.5k
  }
711
114k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
712
108k
    zval_ptr_dtor_nogc(op_2);
713
108k
  }
714
114k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
715
114k
}
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
101k
{
719
101k
  USE_OPLINE
720
721
101k
  SAVE_OPLINE();
722
101k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
723
4
    op_1 = ZVAL_UNDEFINED_OP1();
724
4
  }
725
101k
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
726
2
    op_2 = ZVAL_UNDEFINED_OP2();
727
2
  }
728
101k
  bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2);
729
101k
  if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
730
69.7k
    zval_ptr_dtor_nogc(op_1);
731
69.7k
  }
732
101k
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
733
57.1k
    zval_ptr_dtor_nogc(op_2);
734
57.1k
  }
735
101k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
736
101k
}
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.09k
{
740
5.09k
  USE_OPLINE
741
742
5.09k
  SAVE_OPLINE();
743
5.09k
  if (UNEXPECTED(Z_TYPE_P(op_1) == IS_UNDEF)) {
744
20
    op_1 = ZVAL_UNDEFINED_OP1();
745
20
  }
746
5.09k
  bitwise_not_function(EX_VAR(opline->result.var), op_1);
747
5.09k
  FREE_OP(opline->op1_type, opline->op1.var);
748
5.09k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
749
5.09k
}
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
122
{
753
122
  USE_OPLINE
754
755
122
  SAVE_OPLINE();
756
122
  zend_throw_error(NULL, "Using $this when not in object context");
757
122
  UNDEF_RESULT();
758
122
  HANDLE_EXCEPTION();
759
122
}
760
761
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
762
3.96k
{
763
3.96k
  USE_OPLINE
764
3.96k
  zval *function_name;
765
766
3.96k
  SAVE_OPLINE();
767
3.96k
  function_name = RT_CONSTANT(opline, opline->op2);
768
3.96k
  zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name));
769
3.96k
  HANDLE_EXCEPTION();
770
3.96k
}
771
772
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
773
94
{
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
94
  USE_OPLINE
777
94
  zval *prop, *value;
778
94
  zend_property_info *prop_info;
779
94
  zend_reference *ref;
780
781
94
  SAVE_OPLINE();
782
783
94
  prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC);
784
94
  if (UNEXPECTED(!prop)) {
785
9
    UNDEF_RESULT();
786
9
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
787
9
    HANDLE_EXCEPTION();
788
9
  }
789
790
85
  if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
791
85
   && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) {
792
12
    zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
793
12
    UNDEF_RESULT();
794
12
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
795
12
    HANDLE_EXCEPTION();
796
12
  }
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
10
    ZVAL_COPY(EX_VAR(opline->result.var), prop);
820
10
  }
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
80
{
829
80
  USE_OPLINE
830
80
  zval *prop;
831
80
  zend_property_info *prop_info;
832
833
80
  SAVE_OPLINE();
834
835
80
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC);
836
80
  if (UNEXPECTED(!prop)) {
837
2
    UNDEF_RESULT();
838
2
    HANDLE_EXCEPTION();
839
2
  }
840
841
78
  if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
842
78
   && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) {
843
26
    zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
844
26
    UNDEF_RESULT();
845
26
    HANDLE_EXCEPTION();
846
26
  }
847
848
52
  zend_pre_incdec_property_zval(prop,
849
52
    ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
850
851
52
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
852
52
}
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
880
{
857
880
  USE_OPLINE
858
880
  zval *prop;
859
880
  zend_property_info *prop_info;
860
861
880
  SAVE_OPLINE();
862
863
880
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC);
864
880
  if (UNEXPECTED(!prop)) {
865
19
    UNDEF_RESULT();
866
19
    HANDLE_EXCEPTION();
867
19
  }
868
869
861
  if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
870
861
   && 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
861
  zend_post_incdec_property_zval(prop,
877
861
    ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
878
879
861
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
880
861
}
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.79k
{
885
4.79k
  USE_OPLINE
886
4.79k
  zval *prop;
887
4.79k
  zend_property_info *prop_info;
888
889
4.79k
  SAVE_OPLINE();
890
891
4.79k
  prop = zend_fetch_static_property_address(
892
4.79k
    &prop_info, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type,
893
4.79k
    type == BP_VAR_W ? opline->extended_value : 0 OPLINE_CC EXECUTE_DATA_CC);
894
4.79k
  if (UNEXPECTED(!prop)) {
895
247
    ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS));
896
247
    prop = &EG(uninitialized_zval);
897
4.54k
  } else if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK)
898
4.54k
   && (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)
899
4.54k
   && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) {
900
42
    if (Z_TYPE_P(prop) == IS_OBJECT) {
901
10
      goto copy_deref;
902
32
    } else if (type != BP_VAR_UNSET || Z_TYPE_P(prop) != IS_UNDEF) {
903
22
      zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
904
22
    }
905
32
    prop = &EG(uninitialized_zval);
906
32
  }
907
908
4.78k
  if (type == BP_VAR_R || type == BP_VAR_IS) {
909
3.75k
copy_deref:
910
3.75k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
911
3.75k
  } else {
912
1.03k
    ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
913
1.03k
  }
914
4.79k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
915
4.79k
}
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.41k
{
920
3.41k
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R));
921
3.41k
}
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
869
{
926
869
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W));
927
869
}
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
332
{
938
332
  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
332
  } else {
941
332
    ZEND_VM_TAIL_CALL(ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
942
332
  }
943
332
}
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
180
{
948
180
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET));
949
180
}
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
328
{
954
328
  ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS));
955
328
}
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
563
{
983
563
  USE_OPLINE
984
563
  zval *prop, *value;
985
563
  zend_property_info *prop_info;
986
563
  zend_refcounted *garbage = NULL;
987
988
563
  SAVE_OPLINE();
989
990
563
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
991
563
  if (UNEXPECTED(!prop)) {
992
993
33
    UNDEF_RESULT();
994
33
    HANDLE_EXCEPTION();
995
33
  }
996
997
530
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
998
999
530
  if (ZEND_TYPE_IS_SET(prop_info->type)) {
1000
199
    value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1001
1002
331
  } else {
1003
331
    value = zend_assign_to_variable_ex(prop, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
1004
331
  }
1005
1006
530
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1007
61
    ZVAL_COPY(EX_VAR(opline->result.var), value);
1008
61
  }
1009
1010
530
  if (garbage) {
1011
136
    GC_DTOR_NO_REF(garbage);
1012
136
  }
1013
1014
  /* assign_static_prop has two opcodes! */
1015
530
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1016
530
}
1017
1018
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1019
378
{
1020
378
  USE_OPLINE
1021
378
  zval *prop, *value;
1022
378
  zend_property_info *prop_info;
1023
378
  zend_refcounted *garbage = NULL;
1024
1025
378
  SAVE_OPLINE();
1026
1027
378
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
1028
378
  if (UNEXPECTED(!prop)) {
1029
7
    zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1030
7
    UNDEF_RESULT();
1031
7
    HANDLE_EXCEPTION();
1032
7
  }
1033
1034
371
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
1035
1036
371
  if (ZEND_TYPE_IS_SET(prop_info->type)) {
1037
340
    value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1038
340
    zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1039
340
  } else {
1040
31
    value = zend_assign_to_variable_ex(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
1041
31
  }
1042
1043
371
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1044
11
    ZVAL_COPY(EX_VAR(opline->result.var), value);
1045
11
  }
1046
1047
371
  if (garbage) {
1048
307
    GC_DTOR_NO_REF(garbage);
1049
307
  }
1050
1051
  /* assign_static_prop has two opcodes! */
1052
371
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1053
371
}
1054
1055
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1056
456
{
1057
456
  USE_OPLINE
1058
456
  zval *prop, *value;
1059
456
  zend_property_info *prop_info;
1060
456
  zend_refcounted *garbage = NULL;
1061
1062
456
  SAVE_OPLINE();
1063
1064
456
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
1065
456
  if (UNEXPECTED(!prop)) {
1066
12
    zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1067
12
    UNDEF_RESULT();
1068
12
    HANDLE_EXCEPTION();
1069
12
  }
1070
1071
444
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
1072
1073
444
  if (ZEND_TYPE_IS_SET(prop_info->type)) {
1074
154
    value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1075
154
    zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1076
290
  } else {
1077
290
    value = zend_assign_to_variable_ex(prop, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
1078
290
  }
1079
1080
444
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1081
56
    ZVAL_COPY(EX_VAR(opline->result.var), value);
1082
56
  }
1083
1084
444
  if (garbage) {
1085
117
    GC_DTOR_NO_REF(garbage);
1086
117
  }
1087
1088
  /* assign_static_prop has two opcodes! */
1089
444
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1090
444
}
1091
1092
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1093
81
{
1094
81
  USE_OPLINE
1095
81
  zval *prop, *value;
1096
81
  zend_property_info *prop_info;
1097
81
  zend_refcounted *garbage = NULL;
1098
1099
81
  SAVE_OPLINE();
1100
1101
81
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
1102
81
  if (UNEXPECTED(!prop)) {
1103
1104
9
    UNDEF_RESULT();
1105
9
    HANDLE_EXCEPTION();
1106
9
  }
1107
1108
72
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
1109
1110
72
  if (ZEND_TYPE_IS_SET(prop_info->type)) {
1111
25
    value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1112
1113
47
  } else {
1114
47
    value = zend_assign_to_variable_ex(prop, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
1115
47
  }
1116
1117
72
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1118
31
    ZVAL_COPY(EX_VAR(opline->result.var), value);
1119
31
  }
1120
1121
72
  if (garbage) {
1122
3
    GC_DTOR_NO_REF(garbage);
1123
3
  }
1124
1125
  /* assign_static_prop has two opcodes! */
1126
72
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1127
72
}
1128
1129
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1130
253
{
1131
253
  USE_OPLINE
1132
253
  zval *prop, *value_ptr;
1133
253
  zend_property_info *prop_info;
1134
253
  zend_refcounted *garbage = NULL;
1135
1136
253
  SAVE_OPLINE();
1137
1138
253
  prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC);
1139
253
  if (UNEXPECTED(!prop)) {
1140
4
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
1141
4
    UNDEF_RESULT();
1142
4
    HANDLE_EXCEPTION();
1143
4
  }
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
12
    zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify");
1148
12
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
1149
12
    UNDEF_RESULT();
1150
12
    HANDLE_EXCEPTION();
1151
12
  }
1152
1153
237
  value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, BP_VAR_W);
1154
1155
237
  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
237
  } else if (ZEND_TYPE_IS_SET(prop_info->type)) {
1160
213
    prop = zend_assign_to_typed_property_reference(prop_info, prop, value_ptr, &garbage EXECUTE_DATA_CC);
1161
213
  } else {
1162
24
    zend_assign_to_variable_reference(prop, value_ptr, &garbage);
1163
24
  }
1164
1165
237
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1166
23
    ZVAL_COPY(EX_VAR(opline->result.var), prop);
1167
23
  }
1168
1169
237
  if (garbage) {
1170
62
    GC_DTOR(garbage);
1171
62
  }
1172
1173
237
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
1174
237
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
1175
237
}
1176
1177
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
1178
414k
{
1179
414k
  zend_execute_data *old_execute_data;
1180
414k
  uint32_t call_info = EX_CALL_INFO();
1181
414k
  SAVE_OPLINE();
1182
1183
414k
  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
25.7k
    EG(current_execute_data) = EX(prev_execute_data);
1185
25.7k
    i_free_compiled_variables(execute_data);
1186
1187
#ifdef ZEND_PREFER_RELOAD
1188
    call_info = EX_CALL_INFO();
1189
#endif
1190
25.7k
    if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
1191
6.95k
      OBJ_RELEASE(Z_OBJ(execute_data->This));
1192
18.7k
    } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1193
1.89k
      OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1194
1.89k
    }
1195
25.7k
    EG(vm_stack_top) = (zval*)execute_data;
1196
25.7k
    execute_data = EX(prev_execute_data);
1197
1198
25.7k
    if (UNEXPECTED(EG(exception) != NULL)) {
1199
3.34k
      zend_rethrow_exception(execute_data);
1200
3.34k
      HANDLE_EXCEPTION_LEAVE();
1201
3.34k
    }
1202
1203
22.3k
    LOAD_NEXT_OPLINE();
1204
22.3k
    ZEND_VM_LEAVE();
1205
388k
  } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
1206
860
    EG(current_execute_data) = EX(prev_execute_data);
1207
860
    i_free_compiled_variables(execute_data);
1208
1209
#ifdef ZEND_PREFER_RELOAD
1210
    call_info = EX_CALL_INFO();
1211
#endif
1212
860
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1213
639
      zend_clean_and_cache_symbol_table(EX(symbol_table));
1214
639
    }
1215
1216
860
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
1217
102
      zend_free_extra_named_params(EX(extra_named_params));
1218
102
    }
1219
1220
    /* Free extra args before releasing the closure,
1221
     * as that may free the op_array. */
1222
860
    zend_vm_stack_free_extra_args_ex(call_info, execute_data);
1223
1224
860
    if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
1225
67
      OBJ_RELEASE(Z_OBJ(execute_data->This));
1226
793
    } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1227
55
      OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1228
55
    }
1229
1230
860
    old_execute_data = execute_data;
1231
860
    execute_data = EX(prev_execute_data);
1232
860
    zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
1233
1234
860
    if (UNEXPECTED(EG(exception) != NULL)) {
1235
113
      zend_rethrow_exception(execute_data);
1236
113
      HANDLE_EXCEPTION_LEAVE();
1237
113
    }
1238
1239
747
    LOAD_NEXT_OPLINE();
1240
747
    ZEND_VM_LEAVE();
1241
388k
  } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
1242
912
    if (EX(func)->op_array.last_var > 0) {
1243
273
      zend_detach_symbol_table(execute_data);
1244
273
      call_info |= ZEND_CALL_NEEDS_REATTACH;
1245
273
    }
1246
912
    zend_destroy_static_vars(&EX(func)->op_array);
1247
912
    destroy_op_array(&EX(func)->op_array);
1248
912
    efree_size(EX(func), sizeof(zend_op_array));
1249
912
    old_execute_data = execute_data;
1250
912
    execute_data = EG(current_execute_data) = EX(prev_execute_data);
1251
912
    zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
1252
1253
912
    if (call_info & ZEND_CALL_NEEDS_REATTACH) {
1254
273
      if (EX(func)->op_array.last_var > 0) {
1255
272
        zend_attach_symbol_table(execute_data);
1256
272
      } else {
1257
1
        ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
1258
1
      }
1259
273
    }
1260
912
    if (UNEXPECTED(EG(exception) != NULL)) {
1261
226
      zend_rethrow_exception(execute_data);
1262
226
      HANDLE_EXCEPTION_LEAVE();
1263
226
    }
1264
1265
686
    LOAD_NEXT_OPLINE();
1266
686
    ZEND_VM_LEAVE();
1267
387k
  } else {
1268
387k
    if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
1269
316k
      EG(current_execute_data) = EX(prev_execute_data);
1270
316k
      i_free_compiled_variables(execute_data);
1271
#ifdef ZEND_PREFER_RELOAD
1272
      call_info = EX_CALL_INFO();
1273
#endif
1274
316k
      if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
1275
6.94k
        if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1276
6.21k
          zend_clean_and_cache_symbol_table(EX(symbol_table));
1277
6.21k
        }
1278
6.94k
        zend_vm_stack_free_extra_args_ex(call_info, execute_data);
1279
6.94k
        if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
1280
123
          zend_free_extra_named_params(EX(extra_named_params));
1281
123
        }
1282
6.94k
      }
1283
316k
      if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1284
8.00k
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1285
8.00k
      }
1286
316k
      ZEND_VM_RETURN();
1287
316k
    } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
1288
70.9k
      zend_array *symbol_table = EX(symbol_table);
1289
1290
70.9k
      if (EX(func)->op_array.last_var > 0) {
1291
45.2k
        zend_detach_symbol_table(execute_data);
1292
45.2k
        call_info |= ZEND_CALL_NEEDS_REATTACH;
1293
45.2k
      }
1294
70.9k
      if (call_info & ZEND_CALL_NEEDS_REATTACH) {
1295
45.2k
        old_execute_data = EX(prev_execute_data);
1296
45.2k
        while (old_execute_data) {
1297
199
          if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1298
199
            if (old_execute_data->symbol_table == symbol_table) {
1299
199
              if (old_execute_data->func->op_array.last_var > 0) {
1300
198
                zend_attach_symbol_table(old_execute_data);
1301
198
              } else {
1302
1
                ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
1303
1
              }
1304
199
            }
1305
199
            break;
1306
199
          }
1307
0
          old_execute_data = old_execute_data->prev_execute_data;
1308
0
        }
1309
45.2k
      }
1310
70.9k
      EG(current_execute_data) = EX(prev_execute_data);
1311
70.9k
      ZEND_VM_RETURN();
1312
70.9k
    }
1313
387k
  }
1314
414k
}
1315
1316
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1317
574k
{
1318
574k
  USE_OPLINE
1319
1320
574k
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
1321
574k
}
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.6k
{
1518
10.6k
  USE_OPLINE
1519
10.6k
  zend_execute_data *call = EX(call);
1520
10.6k
  zend_function *fbc = call->func;
1521
10.6k
  zval *ret;
1522
1523
10.6k
  SAVE_OPLINE();
1524
10.6k
  EX(call) = call->prev_execute_data;
1525
1526
10.6k
  ret = NULL;
1527
10.6k
  if (0) {
1528
0
    ret = EX_VAR(opline->result.var);
1529
0
  }
1530
1531
10.6k
  call->prev_execute_data = execute_data;
1532
10.6k
  execute_data = call;
1533
10.6k
  i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1534
10.6k
  LOAD_OPLINE_EX();
1535
1536
1537
10.6k
  ZEND_VM_ENTER_EX();
1538
10.6k
}
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.69k
{
1542
6.69k
  USE_OPLINE
1543
6.69k
  zend_execute_data *call = EX(call);
1544
6.69k
  zend_function *fbc = call->func;
1545
6.69k
  zval *ret;
1546
1547
6.69k
  SAVE_OPLINE();
1548
6.69k
  EX(call) = call->prev_execute_data;
1549
1550
6.69k
  ret = NULL;
1551
6.69k
  if (1) {
1552
6.69k
    ret = EX_VAR(opline->result.var);
1553
6.69k
  }
1554
1555
6.69k
  call->prev_execute_data = execute_data;
1556
6.69k
  execute_data = call;
1557
6.69k
  i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1558
6.69k
  LOAD_OPLINE_EX();
1559
1560
1561
6.69k
  ZEND_VM_ENTER_EX();
1562
6.69k
}
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
145
{
1591
145
  USE_OPLINE
1592
145
  zend_execute_data *call = EX(call);
1593
145
  zend_function *fbc = call->func;
1594
145
  zval *ret;
1595
145
  zval retval;
1596
1597
145
  SAVE_OPLINE();
1598
145
  EX(call) = call->prev_execute_data;
1599
1600
145
  const uint32_t no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
1601
1602
145
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
1603
145
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
1604
74
      zend_deprecated_function(fbc);
1605
74
    }
1606
145
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
1607
74
      zend_nodiscard_function(fbc);
1608
74
    }
1609
145
    if (UNEXPECTED(EG(exception) != NULL)) {
1610
15
      UNDEF_RESULT();
1611
15
      if (!0) {
1612
15
        ret = &retval;
1613
15
        ZVAL_UNDEF(ret);
1614
15
      }
1615
15
      goto fcall_by_name_end;
1616
15
    }
1617
145
  }
1618
1619
130
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1620
130
    ret = NULL;
1621
130
    if (0) {
1622
0
      ret = EX_VAR(opline->result.var);
1623
0
    }
1624
1625
130
    call->prev_execute_data = execute_data;
1626
130
    execute_data = call;
1627
130
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1628
130
    LOAD_OPLINE_EX();
1629
1630
1631
130
    ZEND_VM_ENTER_EX();
1632
130
  } 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
15
fcall_by_name_end:
1672
1673
15
    zend_vm_stack_free_args(call);
1674
1675
15
    uint32_t call_info = ZEND_CALL_INFO(call);
1676
15
    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
15
    } else {
1682
15
      EG(vm_stack_top) = (zval*)call;
1683
15
    }
1684
1685
15
    if (!0) {
1686
15
      i_zval_ptr_dtor(ret);
1687
15
    }
1688
15
  }
1689
1690
15
  if (UNEXPECTED(EG(exception) != NULL)) {
1691
15
    zend_rethrow_exception(execute_data);
1692
15
    HANDLE_EXCEPTION();
1693
15
  }
1694
15
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1695
0
  ZEND_VM_CONTINUE();
1696
15
}
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
0
{
1700
0
  USE_OPLINE
1701
0
  zend_execute_data *call = EX(call);
1702
0
  zend_function *fbc = call->func;
1703
0
  zval *ret;
1704
0
  zval retval;
1705
1706
0
  SAVE_OPLINE();
1707
0
  EX(call) = call->prev_execute_data;
1708
1709
0
  const uint32_t no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
1710
1711
0
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
1712
0
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
1713
0
      zend_deprecated_function(fbc);
1714
0
    }
1715
0
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
1716
0
      zend_nodiscard_function(fbc);
1717
0
    }
1718
0
    if (UNEXPECTED(EG(exception) != NULL)) {
1719
0
      UNDEF_RESULT();
1720
0
      if (!1) {
1721
0
        ret = &retval;
1722
0
        ZVAL_UNDEF(ret);
1723
0
      }
1724
0
      goto fcall_by_name_end;
1725
0
    }
1726
0
  }
1727
1728
0
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1729
0
    ret = NULL;
1730
0
    if (1) {
1731
0
      ret = EX_VAR(opline->result.var);
1732
0
    }
1733
1734
0
    call->prev_execute_data = execute_data;
1735
0
    execute_data = call;
1736
0
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1737
0
    LOAD_OPLINE_EX();
1738
1739
1740
0
    ZEND_VM_ENTER_EX();
1741
0
  } 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
0
fcall_by_name_end:
1781
1782
0
    zend_vm_stack_free_args(call);
1783
1784
0
    uint32_t call_info = ZEND_CALL_INFO(call);
1785
0
    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
0
    } else {
1791
0
      EG(vm_stack_top) = (zval*)call;
1792
0
    }
1793
1794
0
    if (!1) {
1795
0
      i_zval_ptr_dtor(ret);
1796
0
    }
1797
0
  }
1798
1799
0
  if (UNEXPECTED(EG(exception) != NULL)) {
1800
0
    zend_rethrow_exception(execute_data);
1801
0
    HANDLE_EXCEPTION();
1802
0
  }
1803
0
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1804
0
  ZEND_VM_CONTINUE();
1805
0
}
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
972k
{
1920
972k
  USE_OPLINE
1921
972k
  zend_execute_data *call = EX(call);
1922
972k
  zend_function *fbc = call->func;
1923
972k
  zval *ret;
1924
972k
  zval retval;
1925
1926
972k
  SAVE_OPLINE();
1927
972k
  EX(call) = call->prev_execute_data;
1928
1929
972k
  const uint32_t no_discard = 0 ? 0 : ZEND_ACC_NODISCARD;
1930
1931
972k
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
1932
280
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
1933
167
      zend_deprecated_function(fbc);
1934
167
    }
1935
280
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
1936
115
      zend_nodiscard_function(fbc);
1937
115
    }
1938
280
    if (UNEXPECTED(EG(exception) != NULL)) {
1939
10
      if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
1940
0
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
1941
0
      }
1942
10
      UNDEF_RESULT();
1943
10
      if (!0) {
1944
10
        ret = &retval;
1945
10
        ZVAL_UNDEF(ret);
1946
10
      }
1947
10
      goto fcall_end;
1948
10
    }
1949
280
  }
1950
1951
972k
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1952
35.4k
    ret = NULL;
1953
35.4k
    if (0) {
1954
0
      ret = EX_VAR(opline->result.var);
1955
0
    }
1956
1957
35.4k
    call->prev_execute_data = execute_data;
1958
35.4k
    execute_data = call;
1959
35.4k
    i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
1960
1961
35.4k
    if (EXPECTED(zend_execute_ex == execute_ex)) {
1962
7.93k
      LOAD_OPLINE_EX();
1963
1964
1965
7.93k
      ZEND_VM_ENTER_EX();
1966
27.5k
    } else {
1967
27.5k
      SAVE_OPLINE_EX();
1968
1969
27.5k
      execute_data = EX(prev_execute_data);
1970
27.5k
      LOAD_OPLINE();
1971
27.5k
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
1972
27.5k
      zend_execute_ex(call);
1973
27.5k
    }
1974
937k
  } else {
1975
937k
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1976
937k
    if (0) {
1977
0
      ret = NULL;
1978
0
    }
1979
1980
937k
    call->prev_execute_data = execute_data;
1981
937k
    EG(current_execute_data) = call;
1982
1983
937k
#if ZEND_DEBUG
1984
937k
    bool should_throw = zend_internal_call_should_throw(fbc, call);
1985
937k
#endif
1986
1987
937k
    ret = 0 ? EX_VAR(opline->result.var) : &retval;
1988
937k
    ZVAL_NULL(ret);
1989
1990
937k
    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
937k
    } else {
1994
937k
      zend_execute_internal(call, ret);
1995
937k
    }
1996
1997
937k
#if ZEND_DEBUG
1998
937k
    if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
1999
354k
      if (should_throw) {
2000
0
        zend_internal_call_arginfo_violation(call->func);
2001
0
      }
2002
354k
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
2003
354k
        zend_verify_internal_return_type(call->func, ret));
2004
354k
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2005
354k
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2006
354k
      zend_verify_internal_func_info(call->func, ret);
2007
354k
    }
2008
937k
#endif
2009
2010
937k
    ZEND_VM_FCALL_INTERRUPT_CHECK(call);
2011
2012
937k
    EG(current_execute_data) = execute_data;
2013
2014
937k
    goto fcall_end;
2015
937k
  }
2016
2017
27.5k
  if (0) {
2018
925k
fcall_end:
2019
2020
925k
    zend_vm_stack_free_args(call);
2021
925k
    if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2022
218
      zend_free_extra_named_params(call->extra_named_params);
2023
218
    }
2024
2025
925k
    if (!0) {
2026
925k
      i_zval_ptr_dtor(ret);
2027
925k
    }
2028
925k
  }
2029
2030
953k
  if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2031
664k
    OBJ_RELEASE(Z_OBJ(call->This));
2032
664k
  }
2033
2034
953k
  zend_vm_stack_free_call_frame(call);
2035
953k
  if (UNEXPECTED(EG(exception) != NULL)) {
2036
572k
    zend_rethrow_exception(execute_data);
2037
572k
    HANDLE_EXCEPTION();
2038
572k
  }
2039
953k
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
2040
380k
  ZEND_VM_CONTINUE();
2041
953k
}
2042
2043
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2044
238k
{
2045
238k
  USE_OPLINE
2046
238k
  zend_execute_data *call = EX(call);
2047
238k
  zend_function *fbc = call->func;
2048
238k
  zval *ret;
2049
238k
  zval retval;
2050
2051
238k
  SAVE_OPLINE();
2052
238k
  EX(call) = call->prev_execute_data;
2053
2054
238k
  const uint32_t no_discard = 1 ? 0 : ZEND_ACC_NODISCARD;
2055
2056
238k
  if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) {
2057
34
    if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) {
2058
34
      zend_deprecated_function(fbc);
2059
34
    }
2060
34
    if ((fbc->common.fn_flags & no_discard) && EG(exception) == NULL) {
2061
0
      zend_nodiscard_function(fbc);
2062
0
    }
2063
34
    if (UNEXPECTED(EG(exception) != NULL)) {
2064
0
      if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
2065
0
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
2066
0
      }
2067
0
      UNDEF_RESULT();
2068
0
      if (!1) {
2069
0
        ret = &retval;
2070
0
        ZVAL_UNDEF(ret);
2071
0
      }
2072
0
      goto fcall_end;
2073
0
    }
2074
34
  }
2075
2076
238k
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
2077
16.1k
    ret = NULL;
2078
16.1k
    if (1) {
2079
16.1k
      ret = EX_VAR(opline->result.var);
2080
16.1k
    }
2081
2082
16.1k
    call->prev_execute_data = execute_data;
2083
16.1k
    execute_data = call;
2084
16.1k
    i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
2085
2086
16.1k
    if (EXPECTED(zend_execute_ex == execute_ex)) {
2087
3.11k
      LOAD_OPLINE_EX();
2088
2089
2090
3.11k
      ZEND_VM_ENTER_EX();
2091
13.0k
    } else {
2092
13.0k
      SAVE_OPLINE_EX();
2093
2094
13.0k
      execute_data = EX(prev_execute_data);
2095
13.0k
      LOAD_OPLINE();
2096
13.0k
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
2097
13.0k
      zend_execute_ex(call);
2098
13.0k
    }
2099
221k
  } else {
2100
221k
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
2101
221k
    if (0) {
2102
0
      ret = NULL;
2103
0
    }
2104
2105
221k
    call->prev_execute_data = execute_data;
2106
221k
    EG(current_execute_data) = call;
2107
2108
221k
#if ZEND_DEBUG
2109
221k
    bool should_throw = zend_internal_call_should_throw(fbc, call);
2110
221k
#endif
2111
2112
221k
    ret = 1 ? EX_VAR(opline->result.var) : &retval;
2113
221k
    ZVAL_NULL(ret);
2114
2115
221k
    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
221k
    } else {
2119
221k
      zend_execute_internal(call, ret);
2120
221k
    }
2121
2122
221k
#if ZEND_DEBUG
2123
221k
    if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
2124
219k
      if (should_throw) {
2125
0
        zend_internal_call_arginfo_violation(call->func);
2126
0
      }
2127
219k
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
2128
219k
        zend_verify_internal_return_type(call->func, ret));
2129
219k
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2130
219k
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2131
219k
      zend_verify_internal_func_info(call->func, ret);
2132
219k
    }
2133
221k
#endif
2134
2135
221k
    ZEND_VM_FCALL_INTERRUPT_CHECK(call);
2136
2137
221k
    EG(current_execute_data) = execute_data;
2138
2139
221k
    goto fcall_end;
2140
221k
  }
2141
2142
13.0k
  if (0) {
2143
221k
fcall_end:
2144
2145
221k
    zend_vm_stack_free_args(call);
2146
221k
    if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2147
36
      zend_free_extra_named_params(call->extra_named_params);
2148
36
    }
2149
2150
221k
    if (!1) {
2151
0
      i_zval_ptr_dtor(ret);
2152
0
    }
2153
221k
  }
2154
2155
234k
  if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2156
93.7k
    OBJ_RELEASE(Z_OBJ(call->This));
2157
93.7k
  }
2158
2159
234k
  zend_vm_stack_free_call_frame(call);
2160
234k
  if (UNEXPECTED(EG(exception) != NULL)) {
2161
1.94k
    zend_rethrow_exception(execute_data);
2162
1.94k
    HANDLE_EXCEPTION();
2163
1.94k
  }
2164
234k
  ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
2165
232k
  ZEND_VM_CONTINUE();
2166
234k
}
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.82k
{
2296
4.82k
  zval *return_value = EX(return_value);
2297
2298
4.82k
  if (EXPECTED(return_value)) {
2299
4.77k
    USE_OPLINE
2300
4.77k
    zend_generator *generator;
2301
4.77k
    zend_execute_data *gen_execute_data;
2302
4.77k
    uint32_t num_args, used_stack, call_info;
2303
2304
4.77k
    SAVE_OPLINE();
2305
4.77k
    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.77k
    num_args = EX_NUM_ARGS();
2316
4.77k
    if (EXPECTED(num_args <= EX(func)->op_array.num_args)) {
2317
4.52k
      used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var + EX(func)->op_array.T) * sizeof(zval);
2318
4.52k
      gen_execute_data = (zend_execute_data*)emalloc(used_stack);
2319
4.52k
      used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var) * sizeof(zval);
2320
4.52k
    } else {
2321
242
      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
242
      gen_execute_data = (zend_execute_data*)emalloc(used_stack);
2323
242
    }
2324
4.77k
    memcpy(gen_execute_data, execute_data, used_stack);
2325
2326
    /* Save execution context in generator object. */
2327
4.77k
    generator = (zend_generator *) Z_OBJ_P(EX(return_value));
2328
4.77k
    generator->func = gen_execute_data->func;
2329
4.77k
    generator->execute_data = gen_execute_data;
2330
4.77k
    generator->frozen_call_stack = NULL;
2331
4.77k
    generator->execute_fake.opline = NULL;
2332
4.77k
    generator->execute_fake.func = NULL;
2333
4.77k
    generator->execute_fake.prev_execute_data = NULL;
2334
4.77k
    ZVAL_OBJ(&generator->execute_fake.This, (zend_object *) generator);
2335
2336
4.77k
    gen_execute_data->opline = opline;
2337
    /* EX(return_value) keeps pointer to zend_object (not a real zval) */
2338
4.77k
    gen_execute_data->return_value = (zval*)generator;
2339
4.77k
    call_info = Z_TYPE_INFO(EX(This));
2340
4.77k
    if ((call_info & Z_TYPE_MASK) == IS_OBJECT
2341
4.77k
     && (!(call_info & (ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS))
2342
       /* Bug #72523 */
2343
178
      || UNEXPECTED(zend_execute_ex != execute_ex))) {
2344
130
      ZEND_ADD_CALL_FLAG_EX(call_info, ZEND_CALL_RELEASE_THIS);
2345
130
      Z_ADDREF(gen_execute_data->This);
2346
130
    }
2347
4.77k
    ZEND_ADD_CALL_FLAG_EX(call_info, (ZEND_CALL_TOP_FUNCTION | ZEND_CALL_ALLOCATED | ZEND_CALL_GENERATOR));
2348
4.77k
    Z_TYPE_INFO(gen_execute_data->This) = call_info;
2349
4.77k
    gen_execute_data->prev_execute_data = NULL;
2350
2351
4.77k
    call_info = EX_CALL_INFO();
2352
4.77k
    EG(current_execute_data) = EX(prev_execute_data);
2353
4.77k
    if (EXPECTED(!(call_info & (ZEND_CALL_TOP|ZEND_CALL_ALLOCATED)))) {
2354
1.93k
      EG(vm_stack_top) = (zval*)execute_data;
2355
1.93k
      execute_data = EX(prev_execute_data);
2356
1.93k
      LOAD_NEXT_OPLINE();
2357
1.93k
      ZEND_VM_LEAVE();
2358
2.83k
    } else if (EXPECTED(!(call_info & ZEND_CALL_TOP))) {
2359
12
      zend_execute_data *old_execute_data = execute_data;
2360
12
      execute_data = EX(prev_execute_data);
2361
12
      zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
2362
12
      LOAD_NEXT_OPLINE();
2363
12
      ZEND_VM_LEAVE();
2364
2.82k
    } else {
2365
2.82k
      ZEND_VM_RETURN();
2366
2.82k
    }
2367
4.77k
  } else {
2368
55
    ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
2369
55
  }
2370
4.82k
}
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
112
{
2374
112
  USE_OPLINE
2375
2376
112
  SAVE_OPLINE();
2377
2378
112
  zend_cannot_pass_by_reference(_arg_num);
2379
112
  FREE_OP(opline->op1_type, opline->op1.var);
2380
112
  ZVAL_UNDEF(_arg);
2381
112
  HANDLE_EXCEPTION();
2382
112
}
2383
2384
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2385
1.57k
{
2386
1.57k
  USE_OPLINE
2387
1.57k
  zval *args;
2388
1.57k
  uint32_t arg_num;
2389
2390
1.57k
  SAVE_OPLINE();
2391
1.57k
  args = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
2392
1.57k
  arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1;
2393
2394
1.57k
send_again:
2395
1.57k
  if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
2396
1.35k
    HashTable *ht = Z_ARRVAL_P(args);
2397
1.35k
    zval *arg, *top;
2398
1.35k
    zend_string *name;
2399
1.35k
    bool have_named_params = 0;
2400
2401
1.35k
    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.35k
    if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) {
2405
941
      uint32_t tmp_arg_num = arg_num;
2406
941
      bool separate = 0;
2407
2408
      /* check if any of arguments are going to be passed by reference */
2409
4.29k
      ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2410
4.29k
        if (UNEXPECTED(name)) {
2411
1.04k
          void *cache_slot[2] = {NULL, NULL};
2412
1.04k
          tmp_arg_num = zend_get_arg_offset_by_name(
2413
1.04k
            EX(call)->func, name, cache_slot) + 1;
2414
1.04k
        }
2415
4.29k
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, tmp_arg_num)) {
2416
105
          separate = 1;
2417
105
          break;
2418
105
        }
2419
1.57k
        tmp_arg_num++;
2420
1.57k
      } ZEND_HASH_FOREACH_END();
2421
941
      if (separate) {
2422
105
        SEPARATE_ARRAY(args);
2423
105
        ht = Z_ARRVAL_P(args);
2424
105
      }
2425
941
    }
2426
2427
1.23M
    ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2428
1.23M
      if (UNEXPECTED(name)) {
2429
1.22k
        void *cache_slot[2] = {NULL, NULL};
2430
1.22k
        have_named_params = 1;
2431
1.22k
        top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2432
1.22k
        if (UNEXPECTED(!top)) {
2433
18
          FREE_OP(opline->op1_type, opline->op1.var);
2434
18
          HANDLE_EXCEPTION();
2435
18
        }
2436
617k
      } else {
2437
617k
        if (have_named_params) {
2438
15
          zend_throw_error(NULL,
2439
15
            "Cannot use positional argument after named argument during unpacking");
2440
15
          FREE_OP(opline->op1_type, opline->op1.var);
2441
15
          HANDLE_EXCEPTION();
2442
15
        }
2443
2444
617k
        top = ZEND_CALL_ARG(EX(call), arg_num);
2445
617k
        ZEND_CALL_NUM_ARGS(EX(call))++;
2446
617k
      }
2447
2448
619k
      if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2449
291
        if (Z_ISREF_P(arg)) {
2450
11
          Z_ADDREF_P(arg);
2451
11
          ZVAL_REF(top, Z_REF_P(arg));
2452
280
        } else if (opline->op1_type & (IS_VAR|IS_CV)) {
2453
          /* array is already separated above */
2454
226
          ZVAL_MAKE_REF_EX(arg, 2);
2455
226
          ZVAL_REF(top, Z_REF_P(arg));
2456
226
        } else {
2457
54
          Z_TRY_ADDREF_P(arg);
2458
54
          ZVAL_NEW_REF(top, arg);
2459
54
        }
2460
618k
      } else {
2461
618k
        ZVAL_COPY_DEREF(top, arg);
2462
618k
      }
2463
2464
619k
      arg_num++;
2465
619k
    } ZEND_HASH_FOREACH_END();
2466
2467
1.35k
  } else if (EXPECTED(Z_TYPE_P(args) == IS_OBJECT)) {
2468
188
    zend_class_entry *ce = Z_OBJCE_P(args);
2469
188
    zend_object_iterator *iter;
2470
188
    bool have_named_params = 0;
2471
2472
188
    if (!ce || !ce->get_iterator) {
2473
19
      zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(args));
2474
169
    } else {
2475
2476
169
      iter = ce->get_iterator(ce, args, 0);
2477
169
      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
164
      const zend_object_iterator_funcs *funcs = iter->funcs;
2488
164
      if (funcs->rewind) {
2489
164
        funcs->rewind(iter);
2490
164
      }
2491
2492
487
      for (; funcs->valid(iter) == SUCCESS; ++arg_num) {
2493
355
        zval *arg, *top;
2494
2495
355
        if (UNEXPECTED(EG(exception) != NULL)) {
2496
0
          break;
2497
0
        }
2498
2499
355
        arg = funcs->get_current_data(iter);
2500
355
        if (UNEXPECTED(EG(exception) != NULL)) {
2501
0
          break;
2502
0
        }
2503
2504
355
        zend_string *name = NULL;
2505
355
        if (funcs->get_current_key) {
2506
355
          zval key;
2507
355
          funcs->get_current_key(iter, &key);
2508
355
          if (UNEXPECTED(EG(exception) != NULL)) {
2509
0
            break;
2510
0
          }
2511
2512
355
          if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) {
2513
137
            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
126
            name = Z_STR_P(&key);
2521
2522
126
            zend_ulong tmp;
2523
126
            if (ZEND_HANDLE_NUMERIC(name, tmp)) {
2524
0
              name = NULL;
2525
0
            }
2526
126
          }
2527
355
        }
2528
2529
344
        if (UNEXPECTED(name)) {
2530
126
          void *cache_slot[2] = {NULL, NULL};
2531
126
          have_named_params = 1;
2532
126
          top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2533
126
          if (UNEXPECTED(!top)) {
2534
13
            zend_string_release(name);
2535
13
            break;
2536
13
          }
2537
2538
113
          ZVAL_DEREF(arg);
2539
113
          Z_TRY_ADDREF_P(arg);
2540
2541
113
          if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2542
5
            zend_error(
2543
5
              E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
2544
5
              " by unpacking a Traversable, passing by-value instead", arg_num,
2545
5
              EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
2546
5
              EX(call)->func->common.scope ? "::" : "",
2547
5
              ZSTR_VAL(EX(call)->func->common.function_name)
2548
5
            );
2549
5
            ZVAL_NEW_REF(top, arg);
2550
108
          } else {
2551
108
            ZVAL_COPY_VALUE(top, arg);
2552
108
          }
2553
2554
113
          zend_string_release(name);
2555
218
        } else {
2556
218
          if (have_named_params) {
2557
8
            zend_throw_error(NULL,
2558
8
              "Cannot use positional argument after named argument during unpacking");
2559
8
            break;
2560
8
          }
2561
2562
210
          zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1);
2563
210
          top = ZEND_CALL_ARG(EX(call), arg_num);
2564
210
          ZVAL_DEREF(arg);
2565
210
          Z_TRY_ADDREF_P(arg);
2566
2567
210
          if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2568
31
            zend_error(
2569
31
              E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
2570
31
              " by unpacking a Traversable, passing by-value instead", arg_num,
2571
31
              EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
2572
31
              EX(call)->func->common.scope ? "::" : "",
2573
31
              ZSTR_VAL(EX(call)->func->common.function_name)
2574
31
            );
2575
31
            ZVAL_NEW_REF(top, arg);
2576
179
          } else {
2577
179
            ZVAL_COPY_VALUE(top, arg);
2578
179
          }
2579
2580
210
          ZEND_CALL_NUM_ARGS(EX(call))++;
2581
210
        }
2582
2583
323
        funcs->move_forward(iter);
2584
323
      }
2585
2586
164
      zend_iterator_dtor(iter);
2587
164
    }
2588
188
  } else if (EXPECTED(Z_ISREF_P(args))) {
2589
0
    args = Z_REFVAL_P(args);
2590
0
    goto send_again;
2591
36
  } else {
2592
36
    if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(args) == IS_UNDEF)) {
2593
6
      ZVAL_UNDEFINED_OP1();
2594
6
    }
2595
36
    zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(args));
2596
36
  }
2597
2598
1.53k
  FREE_OP(opline->op1_type, opline->op1.var);
2599
1.53k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2600
1.53k
}
2601
2602
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2603
1.25k
{
2604
1.25k
  USE_OPLINE
2605
1.25k
  zval *args;
2606
2607
1.25k
  SAVE_OPLINE();
2608
1.25k
  args = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2609
2610
1.25k
  if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) {
2611
27
    if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) {
2612
0
      args = Z_REFVAL_P(args);
2613
0
      if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
2614
0
        goto send_array;
2615
0
      }
2616
0
    }
2617
27
    zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_zval_value_name(args));
2618
27
    FREE_OP(opline->op2_type, opline->op2.var);
2619
27
    FREE_OP(opline->op1_type, opline->op1.var);
2620
27
    HANDLE_EXCEPTION();
2621
1.22k
  } else {
2622
1.22k
    uint32_t arg_num;
2623
1.22k
    HashTable *ht;
2624
1.22k
    zval *arg, *param;
2625
2626
1.22k
send_array:
2627
1.22k
    ht = Z_ARRVAL_P(args);
2628
1.22k
    if (opline->op2_type != IS_UNUSED) {
2629
      /* We don't need to handle named params in this case,
2630
       * because array_slice() is called with $preserve_keys == false. */
2631
52
      zval *op2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
2632
52
      uint32_t skip = opline->extended_value;
2633
52
      uint32_t count = zend_hash_num_elements(ht);
2634
52
      zend_long len;
2635
52
      if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
2636
0
        len = Z_LVAL_P(op2);
2637
52
      } else if (Z_TYPE_P(op2) == IS_NULL) {
2638
15
        len = count - skip;
2639
37
      } else if (EX_USES_STRICT_TYPES()
2640
37
          || !zend_parse_arg_long_weak(op2, &len, /* arg_num */ 3)) {
2641
30
        zend_type_error(
2642
30
          "array_slice(): Argument #3 ($length) must be of type ?int, %s given",
2643
30
          zend_zval_value_name(op2));
2644
30
        FREE_OP(opline->op2_type, opline->op2.var);
2645
30
        FREE_OP(opline->op1_type, opline->op1.var);
2646
30
        HANDLE_EXCEPTION();
2647
30
      }
2648
2649
22
      if (len < 0) {
2650
0
        len += (zend_long)(count - skip);
2651
0
      }
2652
22
      if (skip < count && len > 0) {
2653
20
        if (len > (zend_long)(count - skip)) {
2654
0
          len = (zend_long)(count - skip);
2655
0
        }
2656
20
        zend_vm_stack_extend_call_frame(&EX(call), 0, len);
2657
20
        arg_num = 1;
2658
20
        param = ZEND_CALL_ARG(EX(call), 1);
2659
136
        ZEND_HASH_FOREACH_VAL(ht, arg) {
2660
136
          bool must_wrap = 0;
2661
136
          if (skip > 0) {
2662
10
            skip--;
2663
10
            continue;
2664
48
          } else if ((zend_long)(arg_num - 1) >= len) {
2665
7
            break;
2666
41
          } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2667
0
            if (UNEXPECTED(!Z_ISREF_P(arg))) {
2668
0
              if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2669
                /* By-value send is not allowed -- emit a warning,
2670
                 * but still perform the call. */
2671
0
                zend_param_must_be_ref(EX(call)->func, arg_num);
2672
0
                must_wrap = 1;
2673
0
              }
2674
0
            }
2675
41
          } else {
2676
41
            if (Z_ISREF_P(arg) &&
2677
41
                !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
2678
              /* don't separate references for __call */
2679
0
              arg = Z_REFVAL_P(arg);
2680
0
            }
2681
41
          }
2682
41
          if (EXPECTED(!must_wrap)) {
2683
41
            ZVAL_COPY(param, arg);
2684
41
          } else {
2685
0
            Z_TRY_ADDREF_P(arg);
2686
0
            ZVAL_NEW_REF(param, arg);
2687
0
          }
2688
41
          ZEND_CALL_NUM_ARGS(EX(call))++;
2689
41
          arg_num++;
2690
41
          param++;
2691
41
        } ZEND_HASH_FOREACH_END();
2692
20
      }
2693
22
      FREE_OP(opline->op2_type, opline->op2.var);
2694
1.17k
    } else {
2695
1.17k
      zend_string *name;
2696
1.17k
      bool have_named_params;
2697
1.17k
      zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
2698
1.17k
      arg_num = 1;
2699
1.17k
      param = ZEND_CALL_ARG(EX(call), 1);
2700
1.17k
      have_named_params = 0;
2701
1.64M
      ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2702
1.64M
        if (name) {
2703
64
          void *cache_slot[2] = {NULL, NULL};
2704
64
          have_named_params = 1;
2705
64
          param = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2706
64
          if (!param) {
2707
16
            FREE_OP(opline->op1_type, opline->op1.var);
2708
16
            HANDLE_EXCEPTION();
2709
16
          }
2710
819k
        } else if (have_named_params) {
2711
10
          zend_throw_error(NULL,
2712
10
            "Cannot use positional argument after named argument");
2713
10
          FREE_OP(opline->op1_type, opline->op1.var);
2714
10
          HANDLE_EXCEPTION();
2715
10
        }
2716
2717
819k
        bool must_wrap = 0;
2718
819k
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2719
355
          if (UNEXPECTED(!Z_ISREF_P(arg))) {
2720
270
            if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2721
              /* By-value send is not allowed -- emit a warning,
2722
               * but still perform the call. */
2723
235
              zend_param_must_be_ref(EX(call)->func, arg_num);
2724
235
              must_wrap = 1;
2725
235
            }
2726
270
          }
2727
819k
        } else {
2728
819k
          if (Z_ISREF_P(arg) &&
2729
819k
              !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
2730
            /* don't separate references for __call */
2731
20
            arg = Z_REFVAL_P(arg);
2732
20
          }
2733
819k
        }
2734
2735
819k
        if (EXPECTED(!must_wrap)) {
2736
819k
          ZVAL_COPY(param, arg);
2737
819k
        } else {
2738
235
          Z_TRY_ADDREF_P(arg);
2739
235
          ZVAL_NEW_REF(param, arg);
2740
235
        }
2741
819k
        if (!name) {
2742
819k
          ZEND_CALL_NUM_ARGS(EX(call))++;
2743
819k
          arg_num++;
2744
819k
          param++;
2745
819k
        }
2746
819k
      } ZEND_HASH_FOREACH_END();
2747
1.17k
    }
2748
1.22k
  }
2749
1.17k
  FREE_OP(opline->op1_type, opline->op1.var);
2750
1.17k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2751
1.17k
}
2752
2753
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
2754
314
{
2755
314
  USE_OPLINE
2756
2757
314
  SAVE_OPLINE();
2758
2759
314
  zend_missing_arg_error(execute_data);
2760
314
  HANDLE_EXCEPTION();
2761
314
}
2762
2763
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)
2764
4.65k
{
2765
4.65k
  USE_OPLINE
2766
2767
4.65k
  SAVE_OPLINE();
2768
4.65k
  if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), opline->op1.num, op_1))) {
2769
615
    HANDLE_EXCEPTION();
2770
615
  }
2771
2772
4.04k
  ZEND_VM_NEXT_OPCODE();
2773
4.04k
}
2774
2775
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2776
1.50k
{
2777
1.50k
  USE_OPLINE
2778
1.50k
  uint32_t arg_num = opline->op1.num;
2779
2780
1.50k
  if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
2781
236
    ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
2782
236
  }
2783
2784
1.26k
  ZEND_VM_NEXT_OPCODE();
2785
1.26k
}
2786
2787
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)
2788
51
{
2789
51
  int ret;
2790
51
  USE_OPLINE
2791
2792
51
  SAVE_OPLINE();
2793
51
  if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
2794
0
    op_1 = ZVAL_UNDEFINED_OP1();
2795
0
  }
2796
51
  if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
2797
0
    op_2 = ZVAL_UNDEFINED_OP2();
2798
0
  }
2799
51
  ret = zend_compare(op_1, op_2);
2800
51
  if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
2801
0
    zval_ptr_dtor_nogc(op_2);
2802
0
  }
2803
51
  ZEND_VM_SMART_BRANCH(ret == 0, 1);
2804
51
}
2805
2806
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2807
233
{
2808
233
  USE_OPLINE
2809
233
  zval *op1;
2810
233
  HashTable *result_ht;
2811
2812
233
  SAVE_OPLINE();
2813
233
  op1 = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2814
233
  result_ht = Z_ARRVAL_P(EX_VAR(opline->result.var));
2815
2816
233
add_unpack_again:
2817
233
  if (EXPECTED(Z_TYPE_P(op1) == IS_ARRAY)) {
2818
148
    HashTable *ht = Z_ARRVAL_P(op1);
2819
148
    zval *val;
2820
2821
148
    if (HT_IS_PACKED(ht) && (zend_hash_num_elements(result_ht) == 0 || HT_IS_PACKED(result_ht))) {
2822
135
      zend_hash_extend(result_ht, result_ht->nNumUsed + zend_hash_num_elements(ht), 1);
2823
135
      ZEND_HASH_FILL_PACKED(result_ht) {
2824
742
        ZEND_HASH_PACKED_FOREACH_VAL(ht, val) {
2825
742
          if (UNEXPECTED(Z_ISREF_P(val)) &&
2826
236
            UNEXPECTED(Z_REFCOUNT_P(val) == 1)) {
2827
77
            val = Z_REFVAL_P(val);
2828
77
          }
2829
742
          Z_TRY_ADDREF_P(val);
2830
742
          ZEND_HASH_FILL_ADD(val);
2831
742
        } ZEND_HASH_FOREACH_END();
2832
135
      } ZEND_HASH_FILL_END();
2833
135
    } else {
2834
13
      zend_string *key;
2835
2836
65
      ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
2837
65
        if (UNEXPECTED(Z_ISREF_P(val)) &&
2838
26
          UNEXPECTED(Z_REFCOUNT_P(val) == 1)) {
2839
0
          val = Z_REFVAL_P(val);
2840
0
        }
2841
65
        Z_TRY_ADDREF_P(val);
2842
65
        if (key) {
2843
0
          zend_hash_update(result_ht, key, val);
2844
26
        } else {
2845
26
          if (!zend_hash_next_index_insert(result_ht, val)) {
2846
13
            zend_cannot_add_element();
2847
13
            zval_ptr_dtor_nogc(val);
2848
13
            break;
2849
13
          }
2850
26
        }
2851
65
      } ZEND_HASH_FOREACH_END();
2852
13
    }
2853
148
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
2854
75
    zend_class_entry *ce = Z_OBJCE_P(op1);
2855
75
    zend_object_iterator *iter;
2856
2857
75
    if (!ce || !ce->get_iterator) {
2858
0
      zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(op1));
2859
75
    } else {
2860
75
      iter = ce->get_iterator(ce, op1, 0);
2861
75
      if (UNEXPECTED(!iter)) {
2862
0
        FREE_OP(opline->op1_type, opline->op1.var);
2863
0
        if (!EG(exception)) {
2864
0
          zend_throw_exception_ex(
2865
0
            NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
2866
0
          );
2867
0
        }
2868
0
        HANDLE_EXCEPTION();
2869
0
      }
2870
2871
75
      const zend_object_iterator_funcs *funcs = iter->funcs;
2872
75
      if (funcs->rewind) {
2873
75
        funcs->rewind(iter);
2874
75
      }
2875
2876
164
      for (; funcs->valid(iter) == SUCCESS; ) {
2877
133
        zval *val;
2878
2879
133
        if (UNEXPECTED(EG(exception) != NULL)) {
2880
0
          break;
2881
0
        }
2882
2883
133
        val = funcs->get_current_data(iter);
2884
133
        if (UNEXPECTED(EG(exception) != NULL)) {
2885
0
          break;
2886
0
        }
2887
2888
133
        zval key;
2889
133
        if (funcs->get_current_key) {
2890
133
          funcs->get_current_key(iter, &key);
2891
133
          if (UNEXPECTED(EG(exception) != NULL)) {
2892
0
            break;
2893
0
          }
2894
2895
133
          if (UNEXPECTED(Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING)) {
2896
44
            zend_throw_error(NULL,
2897
44
              "Keys must be of type int|string during array unpacking");
2898
44
            zval_ptr_dtor(&key);
2899
44
            break;
2900
44
          }
2901
133
        } else {
2902
0
          ZVAL_UNDEF(&key);
2903
0
        }
2904
2905
89
        ZVAL_DEREF(val);
2906
89
        Z_TRY_ADDREF_P(val);
2907
2908
89
        zend_ulong num_key;
2909
89
        if (Z_TYPE(key) == IS_STRING && !ZEND_HANDLE_NUMERIC(Z_STR(key), num_key)) {
2910
0
          zend_hash_update(result_ht, Z_STR(key), val);
2911
0
          zval_ptr_dtor_str(&key);
2912
89
        } else {
2913
89
          zval_ptr_dtor(&key);
2914
89
          if (!zend_hash_next_index_insert(result_ht, val)) {
2915
0
            zend_cannot_add_element();
2916
0
            zval_ptr_dtor_nogc(val);
2917
0
            break;
2918
0
          }
2919
89
        }
2920
2921
89
        funcs->move_forward(iter);
2922
89
        if (UNEXPECTED(EG(exception))) {
2923
0
          break;
2924
0
        }
2925
89
      }
2926
2927
75
      zend_iterator_dtor(iter);
2928
75
    }
2929
75
  } else if (EXPECTED(Z_ISREF_P(op1))) {
2930
0
    op1 = Z_REFVAL_P(op1);
2931
0
    goto add_unpack_again;
2932
10
  } else {
2933
10
    zend_throw_error(NULL, "Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(op1));
2934
10
  }
2935
2936
233
  FREE_OP(opline->op1_type, opline->op1.var);
2937
233
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2938
233
}
2939
2940
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2941
17
{
2942
17
  USE_OPLINE
2943
17
  zval *varname;
2944
17
  zend_string *name, *tmp_name = NULL;
2945
17
  zend_class_entry *ce;
2946
2947
17
  SAVE_OPLINE();
2948
2949
17
  if (opline->op2_type == IS_CONST) {
2950
10
    ce = CACHED_PTR(opline->extended_value);
2951
10
    if (UNEXPECTED(ce == NULL)) {
2952
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);
2953
10
      if (UNEXPECTED(ce == NULL)) {
2954
5
        FREE_OP(opline->op1_type, opline->op1.var);
2955
5
        HANDLE_EXCEPTION();
2956
5
      }
2957
      /*CACHE_PTR(opline->extended_value, ce);*/
2958
10
    }
2959
10
  } else if (opline->op2_type == IS_UNUSED) {
2960
7
    ce = zend_fetch_class(NULL, opline->op2.num);
2961
7
    if (UNEXPECTED(ce == NULL)) {
2962
7
      FREE_OP(opline->op1_type, opline->op1.var);
2963
7
      HANDLE_EXCEPTION();
2964
7
    }
2965
7
  } else {
2966
0
    ce = Z_CE_P(EX_VAR(opline->op2.var));
2967
0
  }
2968
2969
5
  varname = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
2970
5
  if (opline->op1_type == IS_CONST) {
2971
5
    name = Z_STR_P(varname);
2972
5
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
2973
0
    name = Z_STR_P(varname);
2974
0
  } else {
2975
0
    if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
2976
0
      varname = ZVAL_UNDEFINED_OP1();
2977
0
    }
2978
0
    name = zval_try_get_tmp_string(varname, &tmp_name);
2979
0
    if (UNEXPECTED(!name)) {
2980
0
      FREE_OP(opline->op1_type, opline->op1.var);
2981
0
      HANDLE_EXCEPTION();
2982
0
    }
2983
0
  }
2984
2985
5
  zend_std_unset_static_property(ce, name);
2986
2987
5
  zend_tmp_string_release(tmp_name);
2988
5
  FREE_OP(opline->op1_type, opline->op1.var);
2989
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2990
5
}
2991
2992
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
2993
3.66k
{
2994
3.66k
  USE_OPLINE
2995
3.66k
  zval *array;
2996
3.66k
  zval *value;
2997
3.66k
  uint32_t value_type;
2998
3.66k
  HashTable *fe_ht;
2999
3.66k
  HashPosition pos;
3000
3.66k
  Bucket *p;
3001
3.66k
  zend_object_iterator *iter;
3002
3003
3.66k
  array = EX_VAR(opline->op1.var);
3004
3.66k
  SAVE_OPLINE();
3005
3006
3.66k
  ZEND_ASSERT(Z_TYPE_P(array) == IS_OBJECT);
3007
3.66k
  if ((iter = zend_iterator_unwrap(array)) == NULL) {
3008
    /* plain object */
3009
3010
539
    fe_ht = Z_OBJPROP_P(array);
3011
539
    pos = zend_hash_iterator_pos(Z_FE_ITER_P(array), fe_ht);
3012
539
    p = fe_ht->arData + pos;
3013
715
    while (1) {
3014
715
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
3015
        /* reached end of iteration */
3016
136
        goto fe_fetch_r_exit;
3017
136
      }
3018
579
      pos++;
3019
579
      value = &p->val;
3020
579
      value_type = Z_TYPE_INFO_P(value);
3021
579
      if (EXPECTED(value_type != IS_UNDEF)) {
3022
423
        if (UNEXPECTED(value_type == IS_INDIRECT)) {
3023
128
          value = Z_INDIRECT_P(value);
3024
128
          value_type = Z_TYPE_INFO_P(value);
3025
128
          if (EXPECTED(value_type != IS_UNDEF)
3026
128
           && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
3027
113
            break;
3028
113
          }
3029
295
        } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
3030
295
            || !p->key
3031
295
            || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
3032
290
          break;
3033
290
        }
3034
423
      }
3035
176
      p++;
3036
176
    }
3037
403
    EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos;
3038
403
    if (RETURN_VALUE_USED(opline)) {
3039
140
      if (UNEXPECTED(!p->key)) {
3040
0
        ZVAL_LONG(EX_VAR(opline->result.var), p->h);
3041
140
      } else if (ZSTR_VAL(p->key)[0]) {
3042
105
        ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
3043
105
      } else {
3044
35
        const char *class_name, *prop_name;
3045
35
        size_t prop_name_len;
3046
35
        zend_unmangle_property_name_ex(
3047
35
          p->key, &class_name, &prop_name, &prop_name_len);
3048
35
        ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
3049
35
      }
3050
140
    }
3051
3.12k
  } else {
3052
3.12k
    const zend_object_iterator_funcs *funcs = iter->funcs;
3053
3.12k
    if (EXPECTED(++iter->index > 0)) {
3054
      /* This could cause an endless loop if index becomes zero again.
3055
       * In case that ever happens we need an additional flag. */
3056
2.12k
      funcs->move_forward(iter);
3057
2.12k
      if (UNEXPECTED(EG(exception) != NULL)) {
3058
62
        UNDEF_RESULT();
3059
62
        HANDLE_EXCEPTION();
3060
62
      }
3061
2.06k
      if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
3062
        /* reached end of iteration */
3063
738
        if (UNEXPECTED(EG(exception) != NULL)) {
3064
5
          UNDEF_RESULT();
3065
5
          HANDLE_EXCEPTION();
3066
5
        }
3067
869
fe_fetch_r_exit:
3068
869
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
3069
869
        ZEND_VM_CONTINUE();
3070
869
      }
3071
2.06k
    }
3072
2.32k
    value = funcs->get_current_data(iter);
3073
2.32k
    if (UNEXPECTED(EG(exception) != NULL)) {
3074
39
      UNDEF_RESULT();
3075
39
      HANDLE_EXCEPTION();
3076
39
    }
3077
2.28k
    if (!value) {
3078
      /* failure in get_current_data */
3079
0
      goto fe_fetch_r_exit;
3080
0
    }
3081
2.28k
    if (RETURN_VALUE_USED(opline)) {
3082
678
      if (funcs->get_current_key) {
3083
678
        funcs->get_current_key(iter, EX_VAR(opline->result.var));
3084
678
        if (UNEXPECTED(EG(exception) != NULL)) {
3085
27
          UNDEF_RESULT();
3086
27
          HANDLE_EXCEPTION();
3087
27
        }
3088
678
      } else {
3089
0
        ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
3090
0
      }
3091
678
    }
3092
2.25k
    value_type = Z_TYPE_INFO_P(value);
3093
2.25k
  }
3094
3095
2.66k
  if (EXPECTED(opline->op2_type == IS_CV)) {
3096
2.63k
    zval *variable_ptr = EX_VAR(opline->op2.var);
3097
2.63k
    zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
3098
2.63k
  } else {
3099
21
    zval *res = EX_VAR(opline->op2.var);
3100
21
    zend_refcounted *gc = Z_COUNTED_P(value);
3101
3102
21
    ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
3103
21
    if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
3104
0
      GC_ADDREF(gc);
3105
0
    }
3106
21
  }
3107
2.66k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3108
2.66k
}
3109
3110
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3111
298
{
3112
298
  USE_OPLINE
3113
298
  zval *value;
3114
298
  bool result;
3115
3116
298
  SAVE_OPLINE();
3117
3118
298
  value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
3119
3120
298
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
3121
298
    result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
3122
298
        (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
3123
298
  } else {
3124
0
    result = value == NULL || !i_zend_is_true(value);
3125
0
  }
3126
3127
298
  ZEND_VM_SMART_BRANCH(result, 1);
3128
298
}
3129
3130
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3131
29.1k
{
3132
29.1k
  USE_OPLINE
3133
3134
29.1k
  ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
3135
3136
29.1k
  if (!E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))) {
3137
195
    do {
3138
      /* Do not silence fatal errors */
3139
195
      EG(error_reporting) &= E_FATAL_ERRORS;
3140
195
      if (!EG(error_reporting_ini_entry)) {
3141
0
        zval *zv = zend_hash_find_known_hash(EG(ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING));
3142
0
        if (zv) {
3143
0
          EG(error_reporting_ini_entry) = (zend_ini_entry *)Z_PTR_P(zv);
3144
0
        } else {
3145
0
          break;
3146
0
        }
3147
0
      }
3148
195
      if (!EG(error_reporting_ini_entry)->modified) {
3149
0
        if (!EG(modified_ini_directives)) {
3150
0
          ALLOC_HASHTABLE(EG(modified_ini_directives));
3151
0
          zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
3152
0
        }
3153
0
        if (EXPECTED(zend_hash_add_ptr(EG(modified_ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING), EG(error_reporting_ini_entry)) != NULL)) {
3154
0
          EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
3155
0
          EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
3156
0
          EG(error_reporting_ini_entry)->modified = 1;
3157
0
        }
3158
0
      }
3159
195
    } while (0);
3160
195
  }
3161
29.1k
  ZEND_VM_NEXT_OPCODE();
3162
29.1k
}
3163
3164
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3165
0
{
3166
0
  USE_OPLINE
3167
3168
0
  if (!EG(no_extensions)) {
3169
0
    SAVE_OPLINE();
3170
0
    zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, execute_data);
3171
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3172
0
  }
3173
0
  ZEND_VM_NEXT_OPCODE();
3174
0
}
3175
3176
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3177
0
{
3178
0
  USE_OPLINE
3179
3180
0
  if (!EG(no_extensions)) {
3181
0
    SAVE_OPLINE();
3182
0
    zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, execute_data);
3183
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3184
0
  }
3185
0
  ZEND_VM_NEXT_OPCODE();
3186
0
}
3187
3188
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3189
0
{
3190
0
  USE_OPLINE
3191
3192
0
  if (!EG(no_extensions)) {
3193
0
    SAVE_OPLINE();
3194
0
    zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, execute_data);
3195
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3196
0
  }
3197
0
  ZEND_VM_NEXT_OPCODE();
3198
0
}
3199
3200
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3201
863
{
3202
863
  zval *zv;
3203
863
  zend_class_entry *ce;
3204
863
  USE_OPLINE
3205
3206
863
  ce = CACHED_PTR(opline->extended_value);
3207
863
  if (UNEXPECTED(ce == NULL)) {
3208
798
    zend_string *rtd_key = Z_STR_P(RT_CONSTANT(opline, opline->op1));
3209
798
    zv = zend_hash_find_known_hash(EG(class_table), rtd_key);
3210
798
    ZEND_ASSERT(zv != NULL);
3211
798
    ce = Z_CE_P(zv);
3212
798
    if (!(ce->ce_flags & ZEND_ACC_LINKED)) {
3213
160
      SAVE_OPLINE();
3214
160
      ce = zend_do_link_class(ce, (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL, rtd_key);
3215
160
      if (!ce) {
3216
2
        HANDLE_EXCEPTION();
3217
2
      }
3218
160
    }
3219
796
    CACHE_PTR(opline->extended_value, ce);
3220
796
  }
3221
861
  Z_CE_P(EX_VAR(opline->result.var)) = ce;
3222
861
  ZEND_VM_NEXT_OPCODE();
3223
861
}
3224
3225
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3226
81
{
3227
81
  zend_function *func;
3228
81
  USE_OPLINE
3229
3230
81
  SAVE_OPLINE();
3231
81
  func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
3232
81
  do_bind_function(func, RT_CONSTANT(opline, opline->op1));
3233
81
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3234
81
}
3235
3236
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3237
312
{
3238
312
  USE_OPLINE
3239
3240
312
  if ((uint32_t)++EG(ticks_count) >= opline->extended_value) {
3241
244
    EG(ticks_count) = 0;
3242
244
    if (zend_ticks_function) {
3243
244
      SAVE_OPLINE();
3244
244
      zend_fiber_switch_block();
3245
244
      zend_ticks_function(opline->extended_value);
3246
244
      zend_fiber_switch_unblock();
3247
244
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3248
244
    }
3249
244
  }
3250
68
  ZEND_VM_NEXT_OPCODE();
3251
68
}
3252
3253
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3254
0
{
3255
0
  USE_OPLINE
3256
3257
0
  ZEND_VM_NEXT_OPCODE();
3258
0
}
3259
3260
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3261
6.74k
{
3262
6.74k
  USE_OPLINE
3263
3264
6.74k
  ZEND_VM_NEXT_OPCODE();
3265
6.74k
}
3266
3267
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)
3268
883k
{
3269
  /* May be NULL during generator closing (only finally blocks are executed) */
3270
883k
  zend_object *ex = EG(exception);
3271
3272
  /* Walk try/catch/finally structures upwards, performing the necessary actions */
3273
883k
  for (; try_catch_offset != (uint32_t) -1; try_catch_offset--) {
3274
577k
    zend_try_catch_element *try_catch =
3275
577k
      &EX(func)->op_array.try_catch_array[try_catch_offset];
3276
3277
577k
    if (op_num < try_catch->catch_op && ex) {
3278
      /* Go to catch block */
3279
576k
      cleanup_live_vars(execute_data, op_num, try_catch->catch_op);
3280
576k
      ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->catch_op], 0);
3281
3282
576k
    } else if (op_num < try_catch->finally_op) {
3283
378
      if (ex && zend_is_unwind_exit(ex)) {
3284
        /* Don't execute finally blocks on exit (for now) */
3285
18
        continue;
3286
18
      }
3287
3288
      /* Go to finally block */
3289
360
      zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
3290
360
      cleanup_live_vars(execute_data, op_num, try_catch->finally_op);
3291
360
      Z_OBJ_P(fast_call) = EG(exception);
3292
360
      EG(exception) = NULL;
3293
360
      Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1;
3294
360
      ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->finally_op], 0);
3295
3296
360
    } else if (op_num < try_catch->finally_end) {
3297
267
      zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
3298
3299
      /* cleanup incomplete RETURN statement */
3300
267
      if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
3301
267
       && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
3302
40
        zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
3303
3304
40
        zval_ptr_dtor(return_value);
3305
40
      }
3306
3307
      /* Chain potential exception from wrapping finally block */
3308
267
      if (Z_OBJ_P(fast_call)) {
3309
135
        if (ex) {
3310
130
          if (zend_is_unwind_exit(ex) || zend_is_graceful_exit(ex)) {
3311
            /* discard the previously thrown exception */
3312
10
            OBJ_RELEASE(Z_OBJ_P(fast_call));
3313
120
          } else {
3314
120
            zend_exception_set_previous(ex, Z_OBJ_P(fast_call));
3315
120
          }
3316
130
        } else {
3317
5
          ex = EG(exception) = Z_OBJ_P(fast_call);
3318
5
        }
3319
135
      }
3320
267
    }
3321
577k
  }
3322
3323
  /* Uncaught exception */
3324
3325
  /* Don't use 0 because it gets replaced by zend_vm_gen.php. */
3326
305k
  if (zend_observer_fcall_op_array_extension != -1) {
3327
0
    zend_observer_fcall_end(execute_data, NULL);
3328
0
  }
3329
305k
  cleanup_live_vars(execute_data, op_num, 0);
3330
305k
  if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
3331
656
    zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
3332
656
    EG(current_execute_data) = EX(prev_execute_data);
3333
656
    zend_generator_close(generator, 1);
3334
656
    ZEND_VM_RETURN();
3335
305k
  } else {
3336
    /* We didn't execute RETURN, and have to initialize return_value */
3337
305k
    if (EX(return_value)) {
3338
266k
      ZVAL_UNDEF(EX(return_value));
3339
266k
    }
3340
305k
    ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3341
305k
  }
3342
305k
}
3343
3344
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3345
882k
{
3346
882k
  const zend_op *throw_op = EG(opline_before_exception);
3347
3348
  /* Exception was thrown before executing any op */
3349
882k
  if (UNEXPECTED(!throw_op)) {
3350
2
    ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX -1, 0));
3351
2
  }
3352
3353
882k
  uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes;
3354
882k
  int i, current_try_catch_offset = -1;
3355
3356
882k
  if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE)
3357
882k
    && throw_op->extended_value & ZEND_FREE_ON_RETURN) {
3358
    /* exceptions thrown because of loop var destruction on return/break/...
3359
     * are logically thrown at the end of the foreach loop, so adjust the
3360
     * throw_op_num.
3361
     */
3362
32
    const zend_live_range *range = find_live_range(
3363
32
      &EX(func)->op_array, throw_op_num, throw_op->op1.var);
3364
    /* free op1 of the corresponding RETURN */
3365
69
    for (i = throw_op_num; i < range->end; i++) {
3366
69
      if (EX(func)->op_array.opcodes[i].opcode == ZEND_FREE
3367
69
       || EX(func)->op_array.opcodes[i].opcode == ZEND_FE_FREE) {
3368
        /* pass */
3369
37
      } else {
3370
32
        if (EX(func)->op_array.opcodes[i].opcode == ZEND_RETURN
3371
32
         && (EX(func)->op_array.opcodes[i].op1_type & (IS_VAR|IS_TMP_VAR))) {
3372
12
          zval_ptr_dtor(EX_VAR(EX(func)->op_array.opcodes[i].op1.var));
3373
12
        }
3374
32
        break;
3375
32
      }
3376
69
    }
3377
32
    throw_op_num = range->end;
3378
32
  }
3379
3380
  /* Find the innermost try/catch/finally the exception was thrown in */
3381
1.75M
  for (i = 0; i < EX(func)->op_array.last_try_catch; i++) {
3382
915k
    zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i];
3383
915k
    if (try_catch->try_op > throw_op_num) {
3384
      /* further blocks will not be relevant... */
3385
40.9k
      break;
3386
40.9k
    }
3387
874k
    if (throw_op_num < try_catch->catch_op || throw_op_num < try_catch->finally_end) {
3388
578k
      current_try_catch_offset = i;
3389
578k
    }
3390
874k
  }
3391
3392
882k
  cleanup_unfinished_calls(execute_data, throw_op_num);
3393
3394
882k
  if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
3395
49.9k
    switch (throw_op->opcode) {
3396
25
      case ZEND_ADD_ARRAY_ELEMENT:
3397
92
      case ZEND_ADD_ARRAY_UNPACK:
3398
104
      case ZEND_ROPE_INIT:
3399
371
      case ZEND_ROPE_ADD:
3400
371
        break; /* exception while building structures, live range handling will free those */
3401
3402
390
      case ZEND_FETCH_CLASS:
3403
392
      case ZEND_DECLARE_ANON_CLASS:
3404
392
        break; /* return value is zend_class_entry pointer */
3405
3406
49.1k
      default:
3407
        /* smart branch opcodes may not initialize result */
3408
49.1k
        if (!zend_is_smart_branch(throw_op)) {
3409
49.0k
          zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
3410
49.0k
        }
3411
49.9k
    }
3412
49.9k
  }
3413
3414
882k
  ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX current_try_catch_offset, throw_op_num));
3415
882k
}
3416
3417
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3418
0
{
3419
0
  USE_OPLINE
3420
0
  int ret;
3421
3422
0
  SAVE_OPLINE();
3423
0
  ret = zend_user_opcode_handlers[opline->opcode](execute_data);
3424
0
  opline = EX(opline);
3425
3426
0
  switch (ret) {
3427
0
    case ZEND_USER_OPCODE_CONTINUE:
3428
0
      ZEND_VM_CONTINUE();
3429
0
    case ZEND_USER_OPCODE_RETURN:
3430
0
      if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
3431
0
        zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
3432
0
        EG(current_execute_data) = EX(prev_execute_data);
3433
0
        zend_generator_close(generator, 1);
3434
0
        ZEND_VM_RETURN();
3435
0
      } else {
3436
0
        ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3437
0
      }
3438
0
    case ZEND_USER_OPCODE_ENTER:
3439
0
      ZEND_VM_ENTER();
3440
0
    case ZEND_USER_OPCODE_LEAVE:
3441
0
      ZEND_VM_LEAVE();
3442
0
    case ZEND_USER_OPCODE_DISPATCH:
3443
0
      ZEND_VM_DISPATCH(opline->opcode, opline);
3444
0
    default:
3445
0
      ZEND_VM_DISPATCH((uint8_t)(ret & 0xff), opline);
3446
0
  }
3447
0
}
3448
3449
static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
3450
5
{
3451
5
  USE_OPLINE
3452
3453
5
  SAVE_OPLINE();
3454
5
  zend_throw_error(NULL, "Cannot yield from finally in a force-closed generator");
3455
5
  FREE_OP(opline->op2_type, opline->op2.var);
3456
5
  FREE_OP(opline->op1_type, opline->op1.var);
3457
5
  UNDEF_RESULT();
3458
5
  HANDLE_EXCEPTION();
3459
5
}
3460
3461
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3462
105
{
3463
105
  USE_OPLINE
3464
105
  zval *fast_call = EX_VAR(opline->op1.var);
3465
105
  SAVE_OPLINE();
3466
3467
  /* cleanup incomplete RETURN statement */
3468
105
  if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
3469
105
   && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
3470
16
    zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
3471
3472
16
    zval_ptr_dtor(return_value);
3473
16
  }
3474
3475
  /* cleanup delayed exception */
3476
105
  if (Z_OBJ_P(fast_call) != NULL) {
3477
    /* discard the previously thrown exception */
3478
20
    OBJ_RELEASE(Z_OBJ_P(fast_call));
3479
20
    Z_OBJ_P(fast_call) = NULL;
3480
20
  }
3481
3482
105
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3483
105
}
3484
3485
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3486
941
{
3487
941
  USE_OPLINE
3488
941
  zval *fast_call = EX_VAR(opline->result.var);
3489
3490
941
  Z_OBJ_P(fast_call) = NULL;
3491
  /* set return address */
3492
941
  Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.opcodes;
3493
941
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
3494
941
}
3495
3496
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3497
1.01k
{
3498
1.01k
  USE_OPLINE
3499
1.01k
  zval *fast_call = EX_VAR(opline->op1.var);
3500
1.01k
  uint32_t current_try_catch_offset, current_op_num;
3501
3502
1.01k
  if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1) {
3503
763
    const zend_op *fast_ret = EX(func)->op_array.opcodes + Z_OPLINE_NUM_P(fast_call);
3504
3505
763
    ZEND_VM_JMP_EX(fast_ret + 1, 0);
3506
763
  }
3507
3508
  /* special case for unhandled exceptions */
3509
256
  EG(exception) = Z_OBJ_P(fast_call);
3510
256
  Z_OBJ_P(fast_call) = NULL;
3511
256
  current_try_catch_offset = opline->op2.num;
3512
256
  current_op_num = opline - EX(func)->op_array.opcodes;
3513
256
  ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX current_try_catch_offset, current_op_num));
3514
1.01k
}
3515
3516
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3517
3.93k
{
3518
3.93k
  USE_OPLINE
3519
3520
3.93k
  if (EG(assertions) <= 0) {
3521
87
    zend_op *target = OP_JMP_ADDR(opline, opline->op2);
3522
87
    if (RETURN_VALUE_USED(opline)) {
3523
78
      ZVAL_TRUE(EX_VAR(opline->result.var));
3524
78
    }
3525
87
    ZEND_VM_JMP_EX(target, 0);
3526
3.84k
  } else {
3527
3.84k
    ZEND_VM_NEXT_OPCODE();
3528
3.84k
  }
3529
3.93k
}
3530
3531
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3532
2.98k
{
3533
2.98k
  zend_array *args = NULL;
3534
2.98k
  zend_function *fbc = EX(func);
3535
2.98k
  zval *ret = EX(return_value);
3536
2.98k
  uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
3537
2.98k
  uint32_t num_args = EX_NUM_ARGS();
3538
2.98k
  zend_execute_data *call;
3539
3540
2.98k
  SAVE_OPLINE();
3541
3542
2.98k
  if (num_args) {
3543
416
    zval *p = ZEND_CALL_ARG(execute_data, 1);
3544
416
    zval *end = p + num_args;
3545
3546
416
    args = zend_new_array(num_args);
3547
416
    zend_hash_real_init_packed(args);
3548
416
    ZEND_HASH_FILL_PACKED(args) {
3549
507
      do {
3550
507
        ZEND_HASH_FILL_ADD(p);
3551
507
        p++;
3552
507
      } while (p != end);
3553
416
    } ZEND_HASH_FILL_END();
3554
416
  }
3555
3556
2.98k
  call = execute_data;
3557
2.98k
  execute_data = EG(current_execute_data) = EX(prev_execute_data);
3558
3559
2.98k
  call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
3560
2.98k
  ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
3561
2.98k
  ZEND_CALL_NUM_ARGS(call) = 2;
3562
3563
2.98k
  ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
3564
3565
2.98k
  zval *call_args = ZEND_CALL_ARG(call, 2);
3566
2.98k
  if (args) {
3567
416
    ZVAL_ARR(call_args, args);
3568
2.57k
  } else {
3569
2.57k
    ZVAL_EMPTY_ARRAY(call_args);
3570
2.57k
  }
3571
2.98k
  if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3572
676
    if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
3573
656
      GC_ADDREF(call->extra_named_params);
3574
656
      ZVAL_ARR(call_args, call->extra_named_params);
3575
656
    } else {
3576
20
      SEPARATE_ARRAY(call_args);
3577
20
      zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
3578
20
    }
3579
676
  }
3580
2.98k
  zend_free_trampoline(fbc);
3581
2.98k
  fbc = call->func;
3582
3583
2.98k
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3584
2.98k
    if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3585
528
      init_func_run_time_cache(&fbc->op_array);
3586
528
    }
3587
2.98k
    execute_data = call;
3588
2.98k
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
3589
2.98k
    if (EXPECTED(zend_execute_ex == execute_ex)) {
3590
636
      LOAD_OPLINE_EX();
3591
3592
3593
636
      ZEND_VM_ENTER_EX();
3594
2.35k
    } else {
3595
2.35k
      SAVE_OPLINE_EX();
3596
3597
2.35k
      execute_data = EX(prev_execute_data);
3598
2.35k
      if (execute_data) {
3599
2.34k
        LOAD_OPLINE();
3600
2.34k
      }
3601
2.35k
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3602
2.35k
      zend_execute_ex(call);
3603
2.35k
    }
3604
2.98k
  } else {
3605
0
    zval retval;
3606
3607
0
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3608
3609
0
    EG(current_execute_data) = call;
3610
3611
0
#if ZEND_DEBUG
3612
0
    bool should_throw = zend_internal_call_should_throw(fbc, call);
3613
0
#endif
3614
3615
0
    if (ret == NULL) {
3616
0
      ret = &retval;
3617
0
    }
3618
3619
0
    ZVAL_NULL(ret);
3620
3621
0
    if (!zend_execute_internal) {
3622
      /* saves one function call if zend_execute_internal is not used */
3623
0
      fbc->internal_function.handler(call, ret);
3624
0
    } else {
3625
0
      zend_execute_internal(call, ret);
3626
0
    }
3627
3628
0
#if ZEND_DEBUG
3629
0
    if (!EG(exception) && call->func) {
3630
0
      if (should_throw) {
3631
0
        zend_internal_call_arginfo_violation(call->func);
3632
0
      }
3633
0
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3634
0
        zend_verify_internal_return_type(call->func, ret));
3635
0
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3636
0
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
3637
0
      zend_verify_internal_func_info(call->func, ret);
3638
0
    }
3639
0
#endif
3640
3641
0
    EG(current_execute_data) = call->prev_execute_data;
3642
3643
0
    zend_vm_stack_free_args(call);
3644
0
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3645
0
      zend_free_extra_named_params(call->extra_named_params);
3646
0
    }
3647
0
    if (ret == &retval) {
3648
0
      zval_ptr_dtor(ret);
3649
0
    }
3650
0
  }
3651
3652
2.35k
  execute_data = EG(current_execute_data);
3653
3654
2.35k
  if (!execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
3655
743
    ZEND_VM_RETURN();
3656
743
  }
3657
3658
1.60k
  if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
3659
0
    zend_object *object = Z_OBJ(call->This);
3660
0
    OBJ_RELEASE(object);
3661
0
  }
3662
1.60k
  zend_vm_stack_free_call_frame(call);
3663
3664
1.60k
  if (UNEXPECTED(EG(exception) != NULL)) {
3665
0
    zend_rethrow_exception(execute_data);
3666
0
    HANDLE_EXCEPTION_LEAVE();
3667
0
  }
3668
3669
1.60k
  LOAD_OPLINE();
3670
1.60k
  ZEND_VM_INC_OPCODE();
3671
1.60k
  ZEND_VM_LEAVE();
3672
1.60k
}
3673
3674
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3675
0
{
3676
0
  zend_array *args = NULL;
3677
0
  zend_function *fbc = EX(func);
3678
0
  zval *ret = EX(return_value);
3679
0
  uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
3680
0
  uint32_t num_args = EX_NUM_ARGS();
3681
0
  zend_execute_data *call;
3682
3683
0
  SAVE_OPLINE();
3684
3685
0
  if (num_args) {
3686
0
    zval *p = ZEND_CALL_ARG(execute_data, 1);
3687
0
    zval *end = p + num_args;
3688
3689
0
    args = zend_new_array(num_args);
3690
0
    zend_hash_real_init_packed(args);
3691
0
    ZEND_HASH_FILL_PACKED(args) {
3692
0
      do {
3693
0
        ZEND_HASH_FILL_ADD(p);
3694
0
        p++;
3695
0
      } while (p != end);
3696
0
    } ZEND_HASH_FILL_END();
3697
0
  }
3698
3699
0
  call = execute_data;
3700
0
  execute_data = EG(current_execute_data) = EX(prev_execute_data);
3701
3702
0
  call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
3703
0
  ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
3704
0
  ZEND_CALL_NUM_ARGS(call) = 2;
3705
3706
0
  ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
3707
3708
0
  zval *call_args = ZEND_CALL_ARG(call, 2);
3709
0
  if (args) {
3710
0
    ZVAL_ARR(call_args, args);
3711
0
  } else {
3712
0
    ZVAL_EMPTY_ARRAY(call_args);
3713
0
  }
3714
0
  if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3715
0
    if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
3716
0
      GC_ADDREF(call->extra_named_params);
3717
0
      ZVAL_ARR(call_args, call->extra_named_params);
3718
0
    } else {
3719
0
      SEPARATE_ARRAY(call_args);
3720
0
      zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
3721
0
    }
3722
0
  }
3723
0
  zend_free_trampoline(fbc);
3724
0
  fbc = call->func;
3725
3726
0
  if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3727
0
    if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3728
0
      init_func_run_time_cache(&fbc->op_array);
3729
0
    }
3730
0
    execute_data = call;
3731
0
    i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
3732
0
    if (EXPECTED(zend_execute_ex == execute_ex)) {
3733
0
      LOAD_OPLINE_EX();
3734
0
      SAVE_OPLINE();
3735
0
      zend_observer_fcall_begin_specialized(execute_data, false);
3736
0
      ZEND_VM_ENTER_EX();
3737
0
    } else {
3738
0
      SAVE_OPLINE_EX();
3739
0
      zend_observer_fcall_begin_specialized(execute_data, false);
3740
0
      execute_data = EX(prev_execute_data);
3741
0
      if (execute_data) {
3742
0
        LOAD_OPLINE();
3743
0
      }
3744
0
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3745
0
      zend_execute_ex(call);
3746
0
    }
3747
0
  } else {
3748
0
    zval retval;
3749
3750
0
    ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3751
3752
0
    EG(current_execute_data) = call;
3753
3754
0
#if ZEND_DEBUG
3755
0
    bool should_throw = zend_internal_call_should_throw(fbc, call);
3756
0
#endif
3757
3758
0
    if (ret == NULL) {
3759
0
      ret = &retval;
3760
0
    }
3761
3762
0
    ZVAL_NULL(ret);
3763
0
    zend_observer_fcall_begin_specialized(call, false);
3764
0
    if (!zend_execute_internal) {
3765
      /* saves one function call if zend_execute_internal is not used */
3766
0
      fbc->internal_function.handler(call, ret);
3767
0
    } else {
3768
0
      zend_execute_internal(call, ret);
3769
0
    }
3770
3771
0
#if ZEND_DEBUG
3772
0
    if (!EG(exception) && call->func) {
3773
0
      if (should_throw) {
3774
0
        zend_internal_call_arginfo_violation(call->func);
3775
0
      }
3776
0
      ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3777
0
        zend_verify_internal_return_type(call->func, ret));
3778
0
      ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3779
0
        ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
3780
0
      zend_verify_internal_func_info(call->func, ret);
3781
0
    }
3782
0
#endif
3783
0
    zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
3784
3785
0
    EG(current_execute_data) = call->prev_execute_data;
3786
3787
0
    zend_vm_stack_free_args(call);
3788
0
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3789
0
      zend_free_extra_named_params(call->extra_named_params);
3790
0
    }
3791
0
    if (ret == &retval) {
3792
0
      zval_ptr_dtor(ret);
3793
0
    }
3794
0
  }
3795
3796
0
  execute_data = EG(current_execute_data);
3797
3798
0
  if (!execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
3799
0
    ZEND_VM_RETURN();
3800
0
  }
3801
3802
0
  if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
3803
0
    zend_object *object = Z_OBJ(call->This);
3804
0
    OBJ_RELEASE(object);
3805
0
  }
3806
0
  zend_vm_stack_free_call_frame(call);
3807
3808
0
  if (UNEXPECTED(EG(exception) != NULL)) {
3809
0
    zend_rethrow_exception(execute_data);
3810
0
    HANDLE_EXCEPTION_LEAVE();
3811
0
  }
3812
3813
0
  LOAD_OPLINE();
3814
0
  ZEND_VM_INC_OPCODE();
3815
0
  ZEND_VM_LEAVE();
3816
0
}
3817
3818
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3819
0
{
3820
0
  USE_OPLINE
3821
0
  SAVE_OPLINE();
3822
3823
0
  zval *result = EX_VAR(opline->result.var);
3824
0
  ZVAL_NULL(result);
3825
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3826
0
  zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3827
0
  if (EG(exception)) {
3828
0
    FREE_OP(opline->op1_type, opline->op1.var);
3829
0
    FREE_OP(opline->op2_type, opline->op2.var);
3830
0
    HANDLE_EXCEPTION();
3831
0
  }
3832
3833
#if 0 || 0
3834
  if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3835
    zend_frameless_observed_call(execute_data);
3836
  } else
3837
#endif
3838
0
  {
3839
0
    zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline);
3840
0
    function(result, arg1, arg2);
3841
0
  }
3842
3843
0
  FREE_OP(opline->op1_type, opline->op1.var);
3844
  /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3845
0
  if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3846
0
    ZVAL_UNDEF(EX_VAR(opline->op1.var));
3847
0
  }
3848
0
  FREE_OP(opline->op2_type, opline->op2.var);
3849
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3850
0
}
3851
3852
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3853
0
{
3854
0
  USE_OPLINE
3855
0
  SAVE_OPLINE();
3856
3857
0
  zval *result = EX_VAR(opline->result.var);
3858
0
  ZVAL_NULL(result);
3859
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3860
0
  zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3861
0
  if (EG(exception)) {
3862
0
    FREE_OP(opline->op1_type, opline->op1.var);
3863
0
    FREE_OP(opline->op2_type, opline->op2.var);
3864
0
    HANDLE_EXCEPTION();
3865
0
  }
3866
3867
0
#if 0 || 1
3868
0
  if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3869
0
    zend_frameless_observed_call(execute_data);
3870
0
  } else
3871
0
#endif
3872
0
  {
3873
0
    zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline);
3874
0
    function(result, arg1, arg2);
3875
0
  }
3876
3877
0
  FREE_OP(opline->op1_type, opline->op1.var);
3878
  /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3879
0
  if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3880
0
    ZVAL_UNDEF(EX_VAR(opline->op1.var));
3881
0
  }
3882
0
  FREE_OP(opline->op2_type, opline->op2.var);
3883
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3884
0
}
3885
3886
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3887
0
{
3888
0
  USE_OPLINE
3889
0
  SAVE_OPLINE();
3890
3891
0
  zval *result = EX_VAR(opline->result.var);
3892
0
  ZVAL_NULL(result);
3893
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3894
0
  zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3895
0
  zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1);
3896
0
  if (EG(exception)) {
3897
0
    FREE_OP(opline->op1_type, opline->op1.var);
3898
0
    FREE_OP(opline->op2_type, opline->op2.var);
3899
0
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3900
0
    HANDLE_EXCEPTION();
3901
0
  }
3902
3903
#if 0 || 0
3904
  if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3905
    zend_frameless_observed_call(execute_data);
3906
  } else
3907
#endif
3908
0
  {
3909
0
    zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline);
3910
0
    function(result, arg1, arg2, arg3);
3911
0
  }
3912
3913
0
  FREE_OP(opline->op1_type, opline->op1.var);
3914
  /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3915
0
  if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3916
0
    ZVAL_UNDEF(EX_VAR(opline->op1.var));
3917
0
  }
3918
0
  FREE_OP(opline->op2_type, opline->op2.var);
3919
0
  if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
3920
0
    ZVAL_UNDEF(EX_VAR(opline->op2.var));
3921
0
  }
3922
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3923
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
3924
0
}
3925
3926
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3927
0
{
3928
0
  USE_OPLINE
3929
0
  SAVE_OPLINE();
3930
3931
0
  zval *result = EX_VAR(opline->result.var);
3932
0
  ZVAL_NULL(result);
3933
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3934
0
  zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3935
0
  zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1);
3936
0
  if (EG(exception)) {
3937
0
    FREE_OP(opline->op1_type, opline->op1.var);
3938
0
    FREE_OP(opline->op2_type, opline->op2.var);
3939
0
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3940
0
    HANDLE_EXCEPTION();
3941
0
  }
3942
3943
0
#if 0 || 1
3944
0
  if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3945
0
    zend_frameless_observed_call(execute_data);
3946
0
  } else
3947
0
#endif
3948
0
  {
3949
0
    zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline);
3950
0
    function(result, arg1, arg2, arg3);
3951
0
  }
3952
3953
0
  FREE_OP(opline->op1_type, opline->op1.var);
3954
  /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3955
0
  if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3956
0
    ZVAL_UNDEF(EX_VAR(opline->op1.var));
3957
0
  }
3958
0
  FREE_OP(opline->op2_type, opline->op2.var);
3959
0
  if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
3960
0
    ZVAL_UNDEF(EX_VAR(opline->op2.var));
3961
0
  }
3962
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3963
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
3964
0
}
3965
3966
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3967
17.5k
{
3968
17.5k
  USE_OPLINE
3969
3970
17.5k
  OPLINE = OP_JMP_ADDR(opline, opline->op1);
3971
17.5k
  ZEND_VM_CONTINUE();
3972
17.5k
}
3973
3974
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
3975
0
{
3976
0
  zend_atomic_bool_store_ex(&EG(vm_interrupt), false);
3977
0
  SAVE_OPLINE();
3978
0
  if (zend_atomic_bool_load_ex(&EG(timed_out))) {
3979
0
    zend_timeout();
3980
0
  } else if (zend_interrupt_function) {
3981
0
    zend_interrupt_function(execute_data);
3982
0
    if (EG(exception)) {
3983
      /* We have to UNDEF result, because ZEND_HANDLE_EXCEPTION is going to free it */
3984
0
      const zend_op *throw_op = EG(opline_before_exception);
3985
3986
0
      if (throw_op
3987
0
       && throw_op->result_type & (IS_TMP_VAR|IS_VAR)
3988
0
       && throw_op->opcode != ZEND_ADD_ARRAY_ELEMENT
3989
0
       && throw_op->opcode != ZEND_ADD_ARRAY_UNPACK
3990
0
       && throw_op->opcode != ZEND_ROPE_INIT
3991
0
       && throw_op->opcode != ZEND_ROPE_ADD) {
3992
0
        ZVAL_UNDEF(ZEND_CALL_VAR(EG(current_execute_data), throw_op->result.var));
3993
3994
0
      }
3995
0
    }
3996
0
    ZEND_VM_ENTER();
3997
0
  }
3998
0
  ZEND_VM_CONTINUE();
3999
0
}
4000
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4001
4.00k
{
4002
4.00k
  USE_OPLINE
4003
4.00k
  zend_function *fbc;
4004
4.00k
  zval *function_name, *func;
4005
4.00k
  zend_execute_data *call;
4006
4007
4.00k
  fbc = CACHED_PTR(opline->result.num);
4008
4.00k
  if (UNEXPECTED(fbc == NULL)) {
4009
3.99k
    function_name = (zval*)RT_CONSTANT(opline, opline->op2);
4010
3.99k
    func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(function_name+1));
4011
3.99k
    if (UNEXPECTED(func == NULL)) {
4012
3.90k
      ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4013
3.90k
    }
4014
89
    fbc = Z_FUNC_P(func);
4015
89
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
4016
82
      init_func_run_time_cache(&fbc->op_array);
4017
82
    }
4018
89
    CACHE_PTR(opline->result.num, fbc);
4019
89
  }
4020
99
  call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
4021
99
    fbc, opline->extended_value, NULL);
4022
99
  call->prev_execute_data = EX(call);
4023
99
  EX(call) = call;
4024
4025
99
  ZEND_VM_NEXT_OPCODE();
4026
99
}
4027
4028
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4029
47
{
4030
47
  USE_OPLINE
4031
47
  zval *function_name;
4032
47
  zend_execute_data *call;
4033
4034
47
  SAVE_OPLINE();
4035
47
  function_name = RT_CONSTANT(opline, opline->op2);
4036
4037
47
try_function_name:
4038
47
  if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4039
0
    call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4040
47
  } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4041
0
    call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4042
47
  } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4043
40
    call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4044
40
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4045
0
    function_name = Z_REFVAL_P(function_name);
4046
0
    goto try_function_name;
4047
7
  } else {
4048
7
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4049
0
      function_name = ZVAL_UNDEFINED_OP2();
4050
0
      if (UNEXPECTED(EG(exception) != NULL)) {
4051
0
        HANDLE_EXCEPTION();
4052
0
      }
4053
0
    }
4054
7
    zend_throw_error(NULL, "Value of type %s is not callable",
4055
7
      zend_zval_type_name(function_name));
4056
7
    call = NULL;
4057
7
  }
4058
4059
47
  if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
4060
4061
0
    if (UNEXPECTED(EG(exception))) {
4062
0
      if (call) {
4063
0
         if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4064
0
          zend_string_release_ex(call->func->common.function_name, 0);
4065
0
          zend_free_trampoline(call->func);
4066
0
        }
4067
0
        zend_vm_stack_free_call_frame(call);
4068
0
      }
4069
0
      HANDLE_EXCEPTION();
4070
0
    }
4071
47
  } else if (!call) {
4072
22
    HANDLE_EXCEPTION();
4073
22
  }
4074
4075
25
  call->prev_execute_data = EX(call);
4076
25
  EX(call) = call;
4077
4078
25
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4079
25
}
4080
4081
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4082
3.33k
{
4083
3.33k
  USE_OPLINE
4084
3.33k
  zval *func_name;
4085
3.33k
  zval *func;
4086
3.33k
  zend_function *fbc;
4087
3.33k
  zend_execute_data *call;
4088
4089
3.33k
  fbc = CACHED_PTR(opline->result.num);
4090
3.33k
  if (UNEXPECTED(fbc == NULL)) {
4091
1.55k
    func_name = (zval *)RT_CONSTANT(opline, opline->op2);
4092
1.55k
    func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name + 1));
4093
1.55k
    if (func == NULL) {
4094
1.53k
      func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name + 2));
4095
1.53k
      if (UNEXPECTED(func == NULL)) {
4096
62
        ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4097
62
      }
4098
1.53k
    }
4099
1.48k
    fbc = Z_FUNC_P(func);
4100
1.48k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
4101
14
      init_func_run_time_cache(&fbc->op_array);
4102
14
    }
4103
1.48k
    CACHE_PTR(opline->result.num, fbc);
4104
1.48k
  }
4105
4106
3.27k
  call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
4107
3.27k
    fbc, opline->extended_value, NULL);
4108
3.27k
  call->prev_execute_data = EX(call);
4109
3.27k
  EX(call) = call;
4110
4111
3.27k
  ZEND_VM_NEXT_OPCODE();
4112
3.27k
}
4113
4114
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4115
266k
{
4116
266k
  USE_OPLINE
4117
266k
  zval *fname;
4118
266k
  zval *func;
4119
266k
  zend_function *fbc;
4120
266k
  zend_execute_data *call;
4121
4122
266k
  fbc = CACHED_PTR(opline->result.num);
4123
266k
  if (UNEXPECTED(fbc == NULL)) {
4124
162k
    fname = (zval*)RT_CONSTANT(opline, opline->op2);
4125
162k
    func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(fname));
4126
162k
    ZEND_ASSERT(func != NULL && "Function existence must be checked at compile time");
4127
162k
    fbc = Z_FUNC_P(func);
4128
162k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
4129
13.7k
      init_func_run_time_cache(&fbc->op_array);
4130
13.7k
    }
4131
162k
    CACHE_PTR(opline->result.num, fbc);
4132
162k
  }
4133
4134
266k
  call = _zend_vm_stack_push_call_frame_ex(
4135
266k
    opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
4136
266k
    fbc, opline->extended_value, NULL);
4137
266k
  call->prev_execute_data = EX(call);
4138
266k
  EX(call) = call;
4139
4140
266k
  ZEND_VM_NEXT_OPCODE();
4141
266k
}
4142
4143
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4144
171k
{
4145
171k
  USE_OPLINE
4146
171k
  zend_function *fbc;
4147
171k
  zend_execute_data *call;
4148
171k
  fbc = CACHED_PTR(opline->result.num);
4149
171k
  if (UNEXPECTED(fbc == NULL)) {
4150
37.2k
    fbc = Z_PTR(EG(function_table)->arData[Z_EXTRA_P(RT_CONSTANT(opline, opline->op2))].val);
4151
37.2k
    CACHE_PTR(opline->result.num, fbc);
4152
37.2k
  }
4153
171k
  call = _zend_vm_stack_push_call_frame_ex(
4154
171k
    opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
4155
171k
    fbc, opline->extended_value, NULL);
4156
171k
  call->prev_execute_data = EX(call);
4157
171k
  EX(call) = call;
4158
171k
  ZEND_VM_NEXT_OPCODE();
4159
171k
}
4160
4161
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4162
1.90k
{
4163
1.90k
  USE_OPLINE
4164
1.90k
  uint32_t arg_num;
4165
1.90k
  zval *param;
4166
4167
2.93k
  ZEND_VM_REPEATABLE_OPCODE
4168
4169
2.93k
  arg_num = opline->op1.num;
4170
2.93k
  param = EX_VAR(opline->result.var);
4171
2.93k
  if (arg_num > EX_NUM_ARGS()) {
4172
1.40k
    zval *default_value = RT_CONSTANT(opline, opline->op2);
4173
4174
1.40k
    if (Z_OPT_TYPE_P(default_value) == IS_CONSTANT_AST) {
4175
534
      zval *cache_val = (zval*)CACHE_ADDR(Z_CACHE_SLOT_P(default_value));
4176
4177
      /* we keep in cache only not refcounted values */
4178
534
      if (Z_TYPE_P(cache_val) != IS_UNDEF) {
4179
5
        ZVAL_COPY_VALUE(param, cache_val);
4180
529
      } else {
4181
529
        SAVE_OPLINE();
4182
529
        ZVAL_COPY(param, default_value);
4183
529
        zend_ast_evaluate_ctx ctx = {0};
4184
529
        if (UNEXPECTED(zval_update_constant_with_ctx(param, EX(func)->op_array.scope, &ctx) != SUCCESS)) {
4185
142
          zval_ptr_dtor_nogc(param);
4186
142
          ZVAL_UNDEF(param);
4187
142
          HANDLE_EXCEPTION();
4188
142
        }
4189
387
        if (!Z_REFCOUNTED_P(param) && !ctx.had_side_effects) {
4190
226
          ZVAL_COPY_VALUE(cache_val, param);
4191
226
        }
4192
387
      }
4193
392
      goto recv_init_check_type;
4194
866
    } else {
4195
866
      ZVAL_COPY(param, default_value);
4196
866
    }
4197
1.53k
  } else {
4198
1.92k
recv_init_check_type:
4199
1.92k
    if ((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0) {
4200
1.65k
      SAVE_OPLINE();
4201
1.65k
      if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), arg_num, param))) {
4202
51
        HANDLE_EXCEPTION();
4203
51
      }
4204
1.65k
    }
4205
1.92k
  }
4206
4207
2.93k
  ZEND_VM_REPEAT_OPCODE(ZEND_RECV_INIT);
4208
0
  ZEND_VM_NEXT_OPCODE();
4209
0
}
4210
4211
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4212
2.12k
{
4213
2.12k
  USE_OPLINE
4214
2.12k
  zval *function_name;
4215
2.12k
  zend_execute_data *call;
4216
4217
2.12k
  SAVE_OPLINE();
4218
2.12k
  function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
4219
4220
2.12k
try_function_name:
4221
2.12k
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4222
369
    call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4223
1.75k
  } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4224
1.69k
    call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4225
1.69k
  } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4226
48
    call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4227
48
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4228
0
    function_name = Z_REFVAL_P(function_name);
4229
0
    goto try_function_name;
4230
17
  } else {
4231
17
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4232
0
      function_name = ZVAL_UNDEFINED_OP2();
4233
0
      if (UNEXPECTED(EG(exception) != NULL)) {
4234
0
        HANDLE_EXCEPTION();
4235
0
      }
4236
0
    }
4237
17
    zend_throw_error(NULL, "Value of type %s is not callable",
4238
17
      zend_zval_type_name(function_name));
4239
17
    call = NULL;
4240
17
  }
4241
4242
2.12k
  if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) {
4243
2.12k
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
4244
2.12k
    if (UNEXPECTED(EG(exception))) {
4245
79
      if (call) {
4246
0
         if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4247
0
          zend_string_release_ex(call->func->common.function_name, 0);
4248
0
          zend_free_trampoline(call->func);
4249
0
        }
4250
0
        zend_vm_stack_free_call_frame(call);
4251
0
      }
4252
79
      HANDLE_EXCEPTION();
4253
79
    }
4254
2.12k
  } else if (!call) {
4255
0
    HANDLE_EXCEPTION();
4256
0
  }
4257
4258
2.04k
  call->prev_execute_data = EX(call);
4259
2.04k
  EX(call) = call;
4260
4261
2.04k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4262
2.04k
}
4263
4264
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4265
16.3k
{
4266
16.3k
  USE_OPLINE
4267
16.3k
  uint32_t arg_num = opline->op1.num;
4268
16.3k
  zval *param;
4269
4270
16.3k
  if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
4271
78
    ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4272
78
  }
4273
4274
16.2k
  param = EX_VAR(opline->result.var);
4275
4276
16.2k
  if (UNEXPECTED(!(opline->op2.num & (1u << Z_TYPE_P(param))))) {
4277
4.65k
    ZEND_VM_TAIL_CALL(zend_verify_recv_arg_type_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX param));
4278
4.65k
  }
4279
4280
11.5k
  ZEND_VM_NEXT_OPCODE();
4281
11.5k
}
4282
4283
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4284
575
{
4285
575
  USE_OPLINE
4286
575
  uint32_t arg_num = opline->op1.num;
4287
575
  uint32_t arg_count = EX_NUM_ARGS();
4288
575
  zval *params;
4289
4290
575
  SAVE_OPLINE();
4291
4292
575
  params = EX_VAR(opline->result.var);
4293
4294
575
  if (arg_num <= arg_count) {
4295
458
    ZEND_ASSERT(EX(func)->common.fn_flags & ZEND_ACC_VARIADIC);
4296
458
    ZEND_ASSERT(EX(func)->common.num_args == arg_num - 1);
4297
458
    zend_arg_info *arg_info = &EX(func)->common.arg_info[arg_num - 1];
4298
4299
458
    array_init_size(params, arg_count - arg_num + 1);
4300
458
    zend_hash_real_init_packed(Z_ARRVAL_P(params));
4301
458
    ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
4302
458
      zval *param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
4303
458
      if (ZEND_TYPE_IS_SET(arg_info->type)) {
4304
75
        ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_FREE_EXTRA_ARGS);
4305
152
        do {
4306
152
          if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param))) {
4307
26
            ZEND_HASH_FILL_FINISH();
4308
26
            HANDLE_EXCEPTION();
4309
26
          }
4310
4311
126
          if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4312
126
          ZEND_HASH_FILL_ADD(param);
4313
126
          param++;
4314
126
        } while (++arg_num <= arg_count);
4315
383
      } else {
4316
126k
        do {
4317
126k
          if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4318
126k
          ZEND_HASH_FILL_ADD(param);
4319
126k
          param++;
4320
126k
        } while (++arg_num <= arg_count);
4321
383
      }
4322
458
    } ZEND_HASH_FILL_END();
4323
458
  } else {
4324
117
    ZVAL_EMPTY_ARRAY(params);
4325
117
  }
4326
4327
549
  if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
4328
141
    zend_string *name;
4329
141
    zval *param;
4330
141
    zend_arg_info *arg_info = &EX(func)->common.arg_info[EX(func)->common.num_args];
4331
141
    if (ZEND_TYPE_IS_SET(arg_info->type)) {
4332
28
      SEPARATE_ARRAY(params);
4333
172
      ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4334
172
        if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param))) {
4335
3
          HANDLE_EXCEPTION();
4336
3
        }
4337
55
        Z_TRY_ADDREF_P(param);
4338
55
        zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4339
55
      } ZEND_HASH_FOREACH_END();
4340
113
    } else if (zend_hash_num_elements(Z_ARRVAL_P(params)) == 0) {
4341
23
      GC_ADDREF(EX(extra_named_params));
4342
23
      ZVAL_ARR(params, EX(extra_named_params));
4343
90
    } else {
4344
90
      SEPARATE_ARRAY(params);
4345
384
      ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4346
384
        Z_TRY_ADDREF_P(param);
4347
384
        zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4348
384
      } ZEND_HASH_FOREACH_END();
4349
90
    }
4350
141
  }
4351
4352
546
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4353
546
}
4354
4355
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4356
0
{
4357
0
  USE_OPLINE
4358
0
  SAVE_OPLINE();
4359
4360
0
  zval *result = EX_VAR(opline->result.var);
4361
0
  ZVAL_NULL(result);
4362
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
4363
0
  if (EG(exception)) {
4364
0
    FREE_OP(opline->op1_type, opline->op1.var);
4365
0
    HANDLE_EXCEPTION();
4366
0
  }
4367
4368
#if 0 || 0
4369
  if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
4370
    zend_frameless_observed_call(execute_data);
4371
  } else
4372
#endif
4373
0
  {
4374
0
    zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline);
4375
0
    function(result, arg1);
4376
0
  }
4377
0
  FREE_OP(opline->op1_type, opline->op1.var);
4378
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4379
0
}
4380
4381
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4382
0
{
4383
0
  USE_OPLINE
4384
0
  SAVE_OPLINE();
4385
4386
0
  zval *result = EX_VAR(opline->result.var);
4387
0
  ZVAL_NULL(result);
4388
0
  zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
4389
0
  if (EG(exception)) {
4390
0
    FREE_OP(opline->op1_type, opline->op1.var);
4391
0
    HANDLE_EXCEPTION();
4392
0
  }
4393
4394
0
#if 0 || 1
4395
0
  if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
4396
0
    zend_frameless_observed_call(execute_data);
4397
0
  } else
4398
0
#endif
4399
0
  {
4400
0
    zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline);
4401
0
    function(result, arg1);
4402
0
  }
4403
0
  FREE_OP(opline->op1_type, opline->op1.var);
4404
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4405
0
}
4406
4407
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4408
5.08k
{
4409
5.08k
  USE_OPLINE
4410
5.08k
  zval *function_name;
4411
5.08k
  zend_execute_data *call;
4412
4413
5.08k
  SAVE_OPLINE();
4414
5.08k
  function_name = EX_VAR(opline->op2.var);
4415
4416
5.38k
try_function_name:
4417
5.38k
  if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4418
1.12k
    call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4419
4.26k
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4420
3.15k
    call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4421
3.15k
  } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4422
184
    call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4423
932
  } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4424
303
    function_name = Z_REFVAL_P(function_name);
4425
303
    goto try_function_name;
4426
629
  } else {
4427
629
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4428
619
      function_name = ZVAL_UNDEFINED_OP2();
4429
619
      if (UNEXPECTED(EG(exception) != NULL)) {
4430
0
        HANDLE_EXCEPTION();
4431
0
      }
4432
619
    }
4433
629
    zend_throw_error(NULL, "Value of type %s is not callable",
4434
629
      zend_zval_type_name(function_name));
4435
629
    call = NULL;
4436
629
  }
4437
4438
5.08k
  if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
4439
4440
0
    if (UNEXPECTED(EG(exception))) {
4441
0
      if (call) {
4442
0
         if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4443
0
          zend_string_release_ex(call->func->common.function_name, 0);
4444
0
          zend_free_trampoline(call->func);
4445
0
        }
4446
0
        zend_vm_stack_free_call_frame(call);
4447
0
      }
4448
0
      HANDLE_EXCEPTION();
4449
0
    }
4450
5.08k
  } else if (!call) {
4451
753
    HANDLE_EXCEPTION();
4452
753
  }
4453
4454
4.33k
  call->prev_execute_data = EX(call);
4455
4.33k
  EX(call) = call;
4456
4457
4.33k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4458
4.33k
}
4459
4460
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4461
493
{
4462
493
  USE_OPLINE
4463
493
  zval *op1;
4464
4465
493
  op1 = RT_CONSTANT(opline, opline->op1);
4466
493
  if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
4467
0
    ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
4468
0
    ZEND_VM_NEXT_OPCODE();
4469
0
  }
4470
4471
493
  ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1));
4472
493
}
4473
4474
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4475
133
{
4476
133
  USE_OPLINE
4477
133
  zval *val;
4478
4479
133
  val = RT_CONSTANT(opline, opline->op1);
4480
133
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4481
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4482
133
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4483
    /* The result and op1 can be the same cv zval */
4484
133
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
4485
133
    ZVAL_TRUE(EX_VAR(opline->result.var));
4486
133
    if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
4487
0
      SAVE_OPLINE();
4488
0
      ZVAL_UNDEFINED_OP1();
4489
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4490
0
    }
4491
133
  } else {
4492
0
    SAVE_OPLINE();
4493
0
    ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
4494
4495
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4496
0
  }
4497
133
  ZEND_VM_NEXT_OPCODE();
4498
133
}
4499
4500
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4501
347k
{
4502
347k
  USE_OPLINE
4503
347k
  zval *z;
4504
4505
347k
  SAVE_OPLINE();
4506
347k
  z = RT_CONSTANT(opline, opline->op1);
4507
4508
347k
  if (Z_TYPE_P(z) == IS_STRING) {
4509
346k
    zend_string *str = Z_STR_P(z);
4510
4511
346k
    if (ZSTR_LEN(str) != 0) {
4512
346k
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4513
346k
    }
4514
346k
  } else {
4515
951
    zend_string *str = zval_get_string_func(z);
4516
4517
951
    if (ZSTR_LEN(str) != 0) {
4518
691
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4519
691
    } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
4520
0
      ZVAL_UNDEFINED_OP1();
4521
0
    }
4522
951
    zend_string_release_ex(str, 0);
4523
951
  }
4524
4525
347k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4526
347k
}
4527
4528
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4529
36
{
4530
36
  USE_OPLINE
4531
36
  zval *val;
4532
36
  uint8_t op1_type;
4533
4534
36
  val = RT_CONSTANT(opline, opline->op1);
4535
4536
36
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4537
2
    ZEND_VM_NEXT_OPCODE();
4538
34
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4539
16
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4540
0
      SAVE_OPLINE();
4541
0
      ZVAL_UNDEFINED_OP1();
4542
0
      if (UNEXPECTED(EG(exception))) {
4543
0
        HANDLE_EXCEPTION();
4544
0
      }
4545
0
    }
4546
16
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4547
16
  }
4548
4549
36
  SAVE_OPLINE();
4550
18
  op1_type = IS_CONST;
4551
18
  if (i_zend_is_true(val)) {
4552
18
    opline++;
4553
18
  } else {
4554
0
    opline = OP_JMP_ADDR(opline, opline->op2);
4555
0
  }
4556
18
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4557
0
    zval_ptr_dtor_nogc(val);
4558
0
  }
4559
18
  ZEND_VM_JMP(opline);
4560
18
}
4561
4562
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4563
265
{
4564
265
  USE_OPLINE
4565
265
  zval *val;
4566
265
  uint8_t op1_type;
4567
4568
265
  val = RT_CONSTANT(opline, opline->op1);
4569
4570
265
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4571
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4572
265
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4573
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4574
0
      SAVE_OPLINE();
4575
0
      ZVAL_UNDEFINED_OP1();
4576
0
      if (UNEXPECTED(EG(exception))) {
4577
0
        HANDLE_EXCEPTION();
4578
0
      }
4579
0
    }
4580
0
    ZEND_VM_NEXT_OPCODE();
4581
0
  }
4582
4583
265
  SAVE_OPLINE();
4584
265
  op1_type = IS_CONST;
4585
265
  if (i_zend_is_true(val)) {
4586
265
    opline = OP_JMP_ADDR(opline, opline->op2);
4587
265
  } else {
4588
0
    opline++;
4589
0
  }
4590
265
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4591
0
    zval_ptr_dtor_nogc(val);
4592
0
  }
4593
265
  ZEND_VM_JMP(opline);
4594
265
}
4595
4596
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4597
4
{
4598
4
  USE_OPLINE
4599
4
  zval *val;
4600
4
  bool ret;
4601
4602
4
  val = RT_CONSTANT(opline, opline->op1);
4603
4604
4
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4605
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
4606
0
    ZEND_VM_NEXT_OPCODE();
4607
4
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4608
4
    ZVAL_FALSE(EX_VAR(opline->result.var));
4609
4
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4610
0
      SAVE_OPLINE();
4611
0
      ZVAL_UNDEFINED_OP1();
4612
0
      if (UNEXPECTED(EG(exception))) {
4613
0
        HANDLE_EXCEPTION();
4614
0
      }
4615
0
    }
4616
4
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4617
4
  }
4618
4619
4
  SAVE_OPLINE();
4620
0
  ret = i_zend_is_true(val);
4621
4622
0
  if (ret) {
4623
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
4624
0
    opline++;
4625
0
  } else {
4626
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4627
0
    opline = OP_JMP_ADDR(opline, opline->op2);
4628
0
  }
4629
0
  ZEND_VM_JMP(opline);
4630
0
}
4631
4632
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4633
8
{
4634
8
  USE_OPLINE
4635
8
  zval *val;
4636
8
  bool ret;
4637
4638
8
  val = RT_CONSTANT(opline, opline->op1);
4639
4640
8
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4641
8
    ZVAL_TRUE(EX_VAR(opline->result.var));
4642
8
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4643
8
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4644
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4645
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4646
0
      SAVE_OPLINE();
4647
0
      ZVAL_UNDEFINED_OP1();
4648
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4649
0
    } else {
4650
0
      ZEND_VM_NEXT_OPCODE();
4651
0
    }
4652
0
  }
4653
4654
8
  SAVE_OPLINE();
4655
0
  ret = i_zend_is_true(val);
4656
4657
0
  if (ret) {
4658
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
4659
0
    opline = OP_JMP_ADDR(opline, opline->op2);
4660
0
  } else {
4661
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
4662
0
    opline++;
4663
0
  }
4664
0
  ZEND_VM_JMP(opline);
4665
0
}
4666
4667
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4668
91.3k
{
4669
91.3k
  USE_OPLINE
4670
91.3k
  zval *retval_ptr;
4671
91.3k
  zval *return_value;
4672
4673
91.3k
  retval_ptr = RT_CONSTANT(opline, opline->op1);
4674
91.3k
  return_value = EX(return_value);
4675
4676
91.3k
  if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4677
0
    SAVE_OPLINE();
4678
0
    retval_ptr = ZVAL_UNDEFINED_OP1();
4679
0
    if (return_value) {
4680
0
      ZVAL_NULL(return_value);
4681
0
    }
4682
91.3k
  } else if (!return_value) {
4683
73.3k
    if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
4684
0
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4685
0
        SAVE_OPLINE();
4686
0
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
4687
0
      }
4688
0
    }
4689
73.3k
  } else {
4690
18.0k
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4691
18.0k
      ZVAL_COPY_VALUE(return_value, retval_ptr);
4692
18.0k
      if (IS_CONST == IS_CONST) {
4693
18.0k
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4694
0
          Z_ADDREF_P(return_value);
4695
0
        }
4696
18.0k
      }
4697
18.0k
    } else if (IS_CONST == IS_CV) {
4698
0
      do {
4699
0
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4700
0
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4701
0
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4702
0
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4703
0
              ZVAL_COPY_VALUE(return_value, retval_ptr);
4704
0
              if (GC_MAY_LEAK(ref)) {
4705
0
                SAVE_OPLINE();
4706
0
                gc_possible_root(ref);
4707
0
              }
4708
0
              ZVAL_NULL(retval_ptr);
4709
0
              break;
4710
0
            } else {
4711
0
              Z_ADDREF_P(retval_ptr);
4712
0
            }
4713
0
          } else {
4714
0
            retval_ptr = Z_REFVAL_P(retval_ptr);
4715
0
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4716
0
              Z_ADDREF_P(retval_ptr);
4717
0
            }
4718
0
          }
4719
0
        }
4720
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4721
0
      } while (0);
4722
0
    } else /* if (IS_CONST == IS_VAR) */ {
4723
0
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4724
0
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4725
4726
0
        retval_ptr = Z_REFVAL_P(retval_ptr);
4727
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4728
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4729
0
          efree_size(ref, sizeof(zend_reference));
4730
0
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4731
0
          Z_ADDREF_P(retval_ptr);
4732
0
        }
4733
0
      } else {
4734
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4735
0
      }
4736
0
    }
4737
18.0k
  }
4738
4739
4740
4741
91.3k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4742
91.3k
}
4743
4744
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4745
0
{
4746
0
  USE_OPLINE
4747
0
  zval *retval_ptr;
4748
0
  zval *return_value;
4749
0
  zval observer_retval;
4750
4751
0
  retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
4752
0
  return_value = EX(return_value);
4753
0
  if (!return_value) { return_value = &observer_retval; };
4754
0
  if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4755
0
    SAVE_OPLINE();
4756
0
    retval_ptr = ZVAL_UNDEFINED_OP1();
4757
0
    if (return_value) {
4758
0
      ZVAL_NULL(return_value);
4759
0
    }
4760
0
  } else if (!return_value) {
4761
0
    if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
4762
0
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4763
0
        SAVE_OPLINE();
4764
0
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
4765
0
      }
4766
0
    }
4767
0
  } else {
4768
0
    if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
4769
0
      ZVAL_COPY_VALUE(return_value, retval_ptr);
4770
0
      if (opline->op1_type == IS_CONST) {
4771
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4772
0
          Z_ADDREF_P(return_value);
4773
0
        }
4774
0
      }
4775
0
    } else if (opline->op1_type == IS_CV) {
4776
0
      do {
4777
0
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4778
0
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4779
0
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4780
0
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4781
0
              ZVAL_COPY_VALUE(return_value, retval_ptr);
4782
0
              if (GC_MAY_LEAK(ref)) {
4783
0
                SAVE_OPLINE();
4784
0
                gc_possible_root(ref);
4785
0
              }
4786
0
              ZVAL_NULL(retval_ptr);
4787
0
              break;
4788
0
            } else {
4789
0
              Z_ADDREF_P(retval_ptr);
4790
0
            }
4791
0
          } else {
4792
0
            retval_ptr = Z_REFVAL_P(retval_ptr);
4793
0
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4794
0
              Z_ADDREF_P(retval_ptr);
4795
0
            }
4796
0
          }
4797
0
        }
4798
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4799
0
      } while (0);
4800
0
    } else /* if (opline->op1_type == IS_VAR) */ {
4801
0
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4802
0
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4803
4804
0
        retval_ptr = Z_REFVAL_P(retval_ptr);
4805
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4806
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4807
0
          efree_size(ref, sizeof(zend_reference));
4808
0
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4809
0
          Z_ADDREF_P(retval_ptr);
4810
0
        }
4811
0
      } else {
4812
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
4813
0
      }
4814
0
    }
4815
0
  }
4816
0
  SAVE_OPLINE();
4817
0
  zend_observer_fcall_end(execute_data, return_value);
4818
0
  if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4819
0
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4820
0
}
4821
4822
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4823
60
{
4824
60
  USE_OPLINE
4825
60
  zval *retval_ptr;
4826
60
  zval *return_value;
4827
4828
60
  SAVE_OPLINE();
4829
4830
60
  return_value = EX(return_value);
4831
4832
60
  do {
4833
60
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR)) ||
4834
60
        (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4835
      /* Not supposed to happen, but we'll allow it */
4836
60
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
4837
4838
60
      retval_ptr = RT_CONSTANT(opline, opline->op1);
4839
60
      if (!return_value) {
4840
4841
48
      } else {
4842
48
        if (IS_CONST == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4843
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
4844
0
          break;
4845
0
        }
4846
4847
48
        ZVAL_NEW_REF(return_value, retval_ptr);
4848
48
        if (IS_CONST == IS_CONST) {
4849
48
          Z_TRY_ADDREF_P(retval_ptr);
4850
48
        }
4851
48
      }
4852
60
      break;
4853
60
    }
4854
4855
0
    retval_ptr = zend_get_bad_ptr();
4856
4857
0
    if (IS_CONST == IS_VAR) {
4858
0
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4859
0
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4860
0
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
4861
0
        if (return_value) {
4862
0
          ZVAL_NEW_REF(return_value, retval_ptr);
4863
0
        } else {
4864
4865
0
        }
4866
0
        break;
4867
0
      }
4868
0
    }
4869
4870
0
    if (return_value) {
4871
0
      if (Z_ISREF_P(retval_ptr)) {
4872
0
        Z_ADDREF_P(retval_ptr);
4873
0
      } else {
4874
0
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
4875
0
      }
4876
0
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4877
0
    }
4878
4879
0
  } while (0);
4880
4881
4882
60
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4883
60
}
4884
4885
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4886
0
{
4887
0
  USE_OPLINE
4888
0
  zval *retval_ptr;
4889
0
  zval *return_value;
4890
0
  zval observer_retval;
4891
4892
0
  SAVE_OPLINE();
4893
4894
0
  return_value = EX(return_value);
4895
0
  if (!return_value) { return_value = &observer_retval; };
4896
0
  do {
4897
0
    if ((opline->op1_type & (IS_CONST|IS_TMP_VAR)) ||
4898
0
        (opline->op1_type == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4899
      /* Not supposed to happen, but we'll allow it */
4900
0
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
4901
4902
0
      retval_ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
4903
0
      if (!return_value) {
4904
0
        FREE_OP(opline->op1_type, opline->op1.var);
4905
0
      } else {
4906
0
        if (opline->op1_type == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4907
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
4908
0
          break;
4909
0
        }
4910
4911
0
        ZVAL_NEW_REF(return_value, retval_ptr);
4912
0
        if (opline->op1_type == IS_CONST) {
4913
0
          Z_TRY_ADDREF_P(retval_ptr);
4914
0
        }
4915
0
      }
4916
0
      break;
4917
0
    }
4918
4919
0
    retval_ptr = get_zval_ptr_ptr(opline->op1_type, opline->op1, BP_VAR_W);
4920
4921
0
    if (opline->op1_type == IS_VAR) {
4922
0
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4923
0
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4924
0
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
4925
0
        if (return_value) {
4926
0
          ZVAL_NEW_REF(return_value, retval_ptr);
4927
0
        } else {
4928
0
          FREE_OP(opline->op1_type, opline->op1.var);
4929
0
        }
4930
0
        break;
4931
0
      }
4932
0
    }
4933
4934
0
    if (return_value) {
4935
0
      if (Z_ISREF_P(retval_ptr)) {
4936
0
        Z_ADDREF_P(retval_ptr);
4937
0
      } else {
4938
0
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
4939
0
      }
4940
0
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4941
0
    }
4942
4943
0
    FREE_OP(opline->op1_type, opline->op1.var);
4944
0
  } while (0);
4945
4946
0
  zend_observer_fcall_end(execute_data, return_value);
4947
0
  if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4948
0
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4949
0
}
4950
4951
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4952
1.25k
{
4953
1.25k
  USE_OPLINE
4954
1.25k
  zval *retval;
4955
4956
1.25k
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4957
4958
1.25k
  SAVE_OPLINE();
4959
1.25k
  retval = RT_CONSTANT(opline, opline->op1);
4960
4961
  /* Copy return value into generator->retval */
4962
1.25k
  if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4963
1.25k
    ZVAL_COPY_VALUE(&generator->retval, retval);
4964
1.25k
    if (IS_CONST == IS_CONST) {
4965
1.25k
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
4966
0
        Z_ADDREF(generator->retval);
4967
0
      }
4968
1.25k
    }
4969
1.25k
  } else if (IS_CONST == IS_CV) {
4970
0
    ZVAL_COPY_DEREF(&generator->retval, retval);
4971
0
  } else /* if (IS_CONST == IS_VAR) */ {
4972
0
    if (UNEXPECTED(Z_ISREF_P(retval))) {
4973
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
4974
4975
0
      retval = Z_REFVAL_P(retval);
4976
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
4977
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4978
0
        efree_size(ref, sizeof(zend_reference));
4979
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
4980
0
        Z_ADDREF_P(retval);
4981
0
      }
4982
0
    } else {
4983
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
4984
0
    }
4985
0
  }
4986
4987
1.25k
  EG(current_execute_data) = EX(prev_execute_data);
4988
4989
  /* Close the generator to free up resources */
4990
1.25k
  zend_generator_close(generator, 1);
4991
4992
  /* Pass execution back to handling code */
4993
1.25k
  ZEND_VM_RETURN();
4994
1.25k
}
4995
4996
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4997
0
{
4998
0
  USE_OPLINE
4999
0
  zval *retval;
5000
5001
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
5002
5003
0
  SAVE_OPLINE();
5004
0
  retval = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
5005
5006
  /* Copy return value into generator->retval */
5007
0
  if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
5008
0
    ZVAL_COPY_VALUE(&generator->retval, retval);
5009
0
    if (opline->op1_type == IS_CONST) {
5010
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
5011
0
        Z_ADDREF(generator->retval);
5012
0
      }
5013
0
    }
5014
0
  } else if (opline->op1_type == IS_CV) {
5015
0
    ZVAL_COPY_DEREF(&generator->retval, retval);
5016
0
  } else /* if (opline->op1_type == IS_VAR) */ {
5017
0
    if (UNEXPECTED(Z_ISREF_P(retval))) {
5018
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
5019
5020
0
      retval = Z_REFVAL_P(retval);
5021
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
5022
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5023
0
        efree_size(ref, sizeof(zend_reference));
5024
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
5025
0
        Z_ADDREF_P(retval);
5026
0
      }
5027
0
    } else {
5028
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
5029
0
    }
5030
0
  }
5031
5032
0
  zend_observer_fcall_end(generator->execute_data, &generator->retval);
5033
5034
0
  EG(current_execute_data) = EX(prev_execute_data);
5035
5036
  /* Close the generator to free up resources */
5037
0
  zend_generator_close(generator, 1);
5038
5039
  /* Pass execution back to handling code */
5040
0
  ZEND_VM_RETURN();
5041
0
}
5042
5043
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5044
10
{
5045
10
  USE_OPLINE
5046
10
  zval *value;
5047
5048
10
  SAVE_OPLINE();
5049
10
  value = RT_CONSTANT(opline, opline->op1);
5050
5051
10
  do {
5052
10
    if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
5053
10
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
5054
0
        value = Z_REFVAL_P(value);
5055
0
        if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
5056
0
          break;
5057
0
        }
5058
0
      }
5059
10
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5060
0
        ZVAL_UNDEFINED_OP1();
5061
0
        if (UNEXPECTED(EG(exception) != NULL)) {
5062
0
          HANDLE_EXCEPTION();
5063
0
        }
5064
0
      }
5065
10
      zend_throw_error(NULL, "Can only throw objects");
5066
5067
10
      HANDLE_EXCEPTION();
5068
10
    }
5069
10
  } while (0);
5070
5071
0
  zend_exception_save();
5072
0
  Z_TRY_ADDREF_P(value);
5073
0
  zend_throw_exception_object(value);
5074
0
  zend_exception_restore();
5075
5076
0
  HANDLE_EXCEPTION();
5077
0
}
5078
5079
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5080
647k
{
5081
647k
  USE_OPLINE
5082
647k
  zend_class_entry *ce, *catch_ce;
5083
647k
  zend_object *exception;
5084
5085
647k
  SAVE_OPLINE();
5086
  /* Check whether an exception has been thrown, if not, jump over code */
5087
647k
  zend_exception_restore();
5088
647k
  if (EG(exception) == NULL) {
5089
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5090
0
  }
5091
647k
  catch_ce = CACHED_PTR(opline->extended_value & ~ZEND_LAST_CATCH);
5092
647k
  if (UNEXPECTED(catch_ce == NULL)) {
5093
397k
    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);
5094
5095
397k
    CACHE_PTR(opline->extended_value & ~ZEND_LAST_CATCH, catch_ce);
5096
397k
  }
5097
647k
  ce = EG(exception)->ce;
5098
5099
#ifdef HAVE_DTRACE
5100
  if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
5101
    DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
5102
  }
5103
#endif /* HAVE_DTRACE */
5104
5105
647k
  if (ce != catch_ce) {
5106
638k
    if (!catch_ce || !instanceof_function(ce, catch_ce)) {
5107
311k
      if (opline->extended_value & ZEND_LAST_CATCH) {
5108
240k
        zend_rethrow_exception(execute_data);
5109
240k
        HANDLE_EXCEPTION();
5110
240k
      }
5111
70.9k
      ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5112
70.9k
    }
5113
638k
  }
5114
5115
335k
  exception = EG(exception);
5116
335k
  EG(exception) = NULL;
5117
335k
  if (RETURN_VALUE_USED(opline)) {
5118
    /* Always perform a strict assignment. There is a reasonable expectation that if you
5119
     * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
5120
     * we should not permit coercion to string here. */
5121
335k
    zval tmp;
5122
335k
    ZVAL_OBJ(&tmp, exception);
5123
335k
    zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
5124
335k
  } else {
5125
663
    OBJ_RELEASE(exception);
5126
663
  }
5127
335k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5128
335k
}
5129
5130
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5131
257
{
5132
257
  USE_OPLINE
5133
257
  zval *arg, *param;
5134
5135
257
  SAVE_OPLINE();
5136
5137
257
  arg = RT_CONSTANT(opline, opline->op1);
5138
257
  param = ZEND_CALL_VAR(EX(call), opline->result.var);
5139
257
  if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
5140
13
    zend_param_must_be_ref(EX(call)->func, opline->op2.num);
5141
13
    Z_TRY_ADDREF_P(arg);
5142
13
    ZVAL_NEW_REF(param, arg);
5143
244
  } else {
5144
244
    ZVAL_COPY(param, arg);
5145
244
  }
5146
5147
257
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5148
257
}
5149
5150
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5151
1.03k
{
5152
1.03k
  USE_OPLINE
5153
1.03k
  zval *val;
5154
5155
1.03k
  val = RT_CONSTANT(opline, opline->op1);
5156
1.03k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
5157
52
    ZVAL_TRUE(EX_VAR(opline->result.var));
5158
987
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
5159
    /* The result and op1 can be the same cv zval */
5160
85
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
5161
85
    ZVAL_FALSE(EX_VAR(opline->result.var));
5162
85
    if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
5163
0
      SAVE_OPLINE();
5164
0
      ZVAL_UNDEFINED_OP1();
5165
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5166
0
    }
5167
902
  } else {
5168
902
    SAVE_OPLINE();
5169
902
    ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
5170
5171
902
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5172
902
  }
5173
137
  ZEND_VM_NEXT_OPCODE();
5174
137
}
5175
5176
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5177
34
{
5178
34
  USE_OPLINE
5179
34
  zval *obj;
5180
34
  zend_object *zobj;
5181
34
  zend_class_entry *ce, *scope;
5182
34
  zend_function *clone;
5183
34
  zend_object_clone_obj_t clone_call;
5184
5185
34
  SAVE_OPLINE();
5186
34
  obj = RT_CONSTANT(opline, opline->op1);
5187
5188
  /* ZEND_CLONE also exists as the clone() function and both implementations must be kept in sync.
5189
   * The OPcode intentionally does not support a clone-with property list to keep it simple. */
5190
5191
34
  do {
5192
34
    if (IS_CONST == IS_CONST ||
5193
34
        (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
5194
34
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
5195
0
        obj = Z_REFVAL_P(obj);
5196
0
        if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
5197
0
          break;
5198
0
        }
5199
0
      }
5200
34
      ZVAL_UNDEF(EX_VAR(opline->result.var));
5201
34
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
5202
0
        ZVAL_UNDEFINED_OP1();
5203
0
        if (UNEXPECTED(EG(exception) != NULL)) {
5204
0
          HANDLE_EXCEPTION();
5205
0
        }
5206
0
      }
5207
34
      zend_type_error("clone(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(obj));
5208
5209
34
      HANDLE_EXCEPTION();
5210
34
    }
5211
34
  } while (0);
5212
5213
0
  zobj = Z_OBJ_P(obj);
5214
0
  ce = zobj->ce;
5215
0
  clone = ce->clone;
5216
0
  clone_call = zobj->handlers->clone_obj;
5217
0
  if (UNEXPECTED(clone_call == NULL)) {
5218
0
    zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
5219
5220
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
5221
0
    HANDLE_EXCEPTION();
5222
0
  }
5223
5224
0
  if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
5225
0
    scope = EX(func)->op_array.scope;
5226
0
    ZEND_ASSERT(!(clone->common.fn_flags & ZEND_ACC_PUBLIC));
5227
0
    if (!zend_check_method_accessible(clone, scope)) {
5228
0
      zend_bad_method_call(clone, clone->common.function_name, scope);
5229
5230
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
5231
0
      HANDLE_EXCEPTION();
5232
0
    }
5233
0
  }
5234
5235
0
  ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
5236
5237
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5238
0
}
5239
5240
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5241
440
{
5242
440
  USE_OPLINE
5243
440
  zval *expr;
5244
440
  zval *result = EX_VAR(opline->result.var);
5245
5246
440
  SAVE_OPLINE();
5247
440
  expr = RT_CONSTANT(opline, opline->op1);
5248
5249
440
  switch (opline->extended_value) {
5250
34
    case IS_LONG:
5251
34
      ZVAL_LONG(result, zval_get_long(expr));
5252
34
      break;
5253
0
    case IS_DOUBLE:
5254
0
      ZVAL_DOUBLE(result, zval_get_double(expr));
5255
0
      break;
5256
128
    case IS_STRING:
5257
128
      ZVAL_STR(result, zval_get_string(expr));
5258
128
      break;
5259
278
    default:
5260
278
      ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
5261
278
      if (IS_CONST & (IS_VAR|IS_CV)) {
5262
0
        ZVAL_DEREF(expr);
5263
0
      }
5264
      /* If value is already of correct type, return it directly */
5265
278
      if (Z_TYPE_P(expr) == opline->extended_value) {
5266
0
        ZVAL_COPY_VALUE(result, expr);
5267
0
        if (IS_CONST == IS_CONST) {
5268
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5269
0
        } else if (IS_CONST != IS_TMP_VAR) {
5270
0
          if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5271
0
        }
5272
5273
0
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5274
0
      }
5275
5276
278
      if (opline->extended_value == IS_ARRAY) {
5277
0
        zend_cast_zval_to_array(result, expr, IS_CONST);
5278
278
      } else {
5279
278
        ZEND_ASSERT(opline->extended_value == IS_OBJECT);
5280
278
        zend_cast_zval_to_object(result, expr, IS_CONST);
5281
278
      }
5282
440
  }
5283
5284
440
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5285
440
}
5286
5287
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5288
106k
{
5289
106k
  USE_OPLINE
5290
106k
  zend_op_array *new_op_array;
5291
106k
  zval *inc_filename;
5292
5293
106k
  SAVE_OPLINE();
5294
106k
  inc_filename = RT_CONSTANT(opline, opline->op1);
5295
106k
  new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5296
106k
  if (UNEXPECTED(EG(exception) != NULL)) {
5297
5298
410
    if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5299
0
      destroy_op_array(new_op_array);
5300
0
      efree_size(new_op_array, sizeof(zend_op_array));
5301
0
    }
5302
410
    UNDEF_RESULT();
5303
410
    HANDLE_EXCEPTION();
5304
105k
  } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5305
0
    if (RETURN_VALUE_USED(opline)) {
5306
0
      ZVAL_TRUE(EX_VAR(opline->result.var));
5307
0
    }
5308
105k
  } else if (UNEXPECTED(new_op_array == NULL)) {
5309
1.67k
    if (RETURN_VALUE_USED(opline)) {
5310
3
      ZVAL_FALSE(EX_VAR(opline->result.var));
5311
3
    }
5312
103k
  } else if (new_op_array->last == 1
5313
103k
      && new_op_array->opcodes[0].opcode == ZEND_RETURN
5314
103k
      && new_op_array->opcodes[0].op1_type == IS_CONST
5315
103k
      && EXPECTED(zend_execute_ex == execute_ex)) {
5316
28.3k
    if (RETURN_VALUE_USED(opline)) {
5317
28.1k
      const zend_op *op = new_op_array->opcodes;
5318
5319
28.1k
      ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5320
28.1k
    }
5321
28.3k
    zend_destroy_static_vars(new_op_array);
5322
28.3k
    destroy_op_array(new_op_array);
5323
28.3k
    efree_size(new_op_array, sizeof(zend_op_array));
5324
75.6k
  } else {
5325
75.6k
    zval *return_value = NULL;
5326
75.6k
    zend_execute_data *call;
5327
75.6k
    if (RETURN_VALUE_USED(opline)) {
5328
74.0k
      return_value = EX_VAR(opline->result.var);
5329
74.0k
    }
5330
5331
75.6k
    new_op_array->scope = EX(func)->op_array.scope;
5332
5333
75.6k
    call = zend_vm_stack_push_call_frame(
5334
75.6k
      (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5335
75.6k
      (zend_function*)new_op_array, 0,
5336
75.6k
      Z_PTR(EX(This)));
5337
5338
75.6k
    if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5339
75.2k
      call->symbol_table = EX(symbol_table);
5340
75.2k
    } else {
5341
466
      call->symbol_table = zend_rebuild_symbol_table();
5342
466
    }
5343
5344
75.6k
    call->prev_execute_data = execute_data;
5345
75.6k
    i_init_code_execute_data(call, new_op_array, return_value);
5346
5347
75.6k
    if (EXPECTED(zend_execute_ex == execute_ex)) {
5348
5349
723
      ZEND_VM_ENTER();
5350
74.9k
    } else {
5351
74.9k
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5352
74.9k
      zend_execute_ex(call);
5353
74.9k
      zend_vm_stack_free_call_frame(call);
5354
74.9k
    }
5355
5356
74.9k
    zend_destroy_static_vars(new_op_array);
5357
74.9k
    destroy_op_array(new_op_array);
5358
74.9k
    efree_size(new_op_array, sizeof(zend_op_array));
5359
74.9k
    if (UNEXPECTED(EG(exception) != NULL)) {
5360
39
      zend_rethrow_exception(execute_data);
5361
5362
39
      UNDEF_RESULT();
5363
39
      HANDLE_EXCEPTION();
5364
39
    }
5365
74.9k
  }
5366
5367
104k
  ZEND_VM_NEXT_OPCODE();
5368
104k
}
5369
5370
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5371
0
{
5372
0
  USE_OPLINE
5373
0
  zend_op_array *new_op_array;
5374
0
  zval *inc_filename;
5375
5376
0
  SAVE_OPLINE();
5377
0
  inc_filename = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
5378
0
  new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5379
0
  if (UNEXPECTED(EG(exception) != NULL)) {
5380
0
    FREE_OP(opline->op1_type, opline->op1.var);
5381
0
    if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5382
0
      destroy_op_array(new_op_array);
5383
0
      efree_size(new_op_array, sizeof(zend_op_array));
5384
0
    }
5385
0
    UNDEF_RESULT();
5386
0
    HANDLE_EXCEPTION();
5387
0
  } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5388
0
    if (RETURN_VALUE_USED(opline)) {
5389
0
      ZVAL_TRUE(EX_VAR(opline->result.var));
5390
0
    }
5391
0
  } else if (UNEXPECTED(new_op_array == NULL)) {
5392
0
    if (RETURN_VALUE_USED(opline)) {
5393
0
      ZVAL_FALSE(EX_VAR(opline->result.var));
5394
0
    }
5395
0
  } else if (new_op_array->last == 1
5396
0
      && new_op_array->opcodes[0].opcode == ZEND_RETURN
5397
0
      && new_op_array->opcodes[0].op1_type == IS_CONST
5398
0
      && EXPECTED(zend_execute_ex == execute_ex)) {
5399
0
    if (RETURN_VALUE_USED(opline)) {
5400
0
      const zend_op *op = new_op_array->opcodes;
5401
5402
0
      ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5403
0
    }
5404
0
    zend_destroy_static_vars(new_op_array);
5405
0
    destroy_op_array(new_op_array);
5406
0
    efree_size(new_op_array, sizeof(zend_op_array));
5407
0
  } else {
5408
0
    zval *return_value = NULL;
5409
0
    zend_execute_data *call;
5410
0
    if (RETURN_VALUE_USED(opline)) {
5411
0
      return_value = EX_VAR(opline->result.var);
5412
0
    }
5413
5414
0
    new_op_array->scope = EX(func)->op_array.scope;
5415
5416
0
    call = zend_vm_stack_push_call_frame(
5417
0
      (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5418
0
      (zend_function*)new_op_array, 0,
5419
0
      Z_PTR(EX(This)));
5420
5421
0
    if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5422
0
      call->symbol_table = EX(symbol_table);
5423
0
    } else {
5424
0
      call->symbol_table = zend_rebuild_symbol_table();
5425
0
    }
5426
5427
0
    call->prev_execute_data = execute_data;
5428
0
    i_init_code_execute_data(call, new_op_array, return_value);
5429
0
    zend_observer_fcall_begin_specialized(call, false);
5430
0
    if (EXPECTED(zend_execute_ex == execute_ex)) {
5431
0
      FREE_OP(opline->op1_type, opline->op1.var);
5432
0
      ZEND_VM_ENTER();
5433
0
    } else {
5434
0
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5435
0
      zend_execute_ex(call);
5436
0
      zend_vm_stack_free_call_frame(call);
5437
0
    }
5438
5439
0
    zend_destroy_static_vars(new_op_array);
5440
0
    destroy_op_array(new_op_array);
5441
0
    efree_size(new_op_array, sizeof(zend_op_array));
5442
0
    if (UNEXPECTED(EG(exception) != NULL)) {
5443
0
      zend_rethrow_exception(execute_data);
5444
0
      FREE_OP(opline->op1_type, opline->op1.var);
5445
0
      UNDEF_RESULT();
5446
0
      HANDLE_EXCEPTION();
5447
0
    }
5448
0
  }
5449
0
  FREE_OP(opline->op1_type, opline->op1.var);
5450
0
  ZEND_VM_NEXT_OPCODE();
5451
0
}
5452
5453
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5454
602
{
5455
602
  USE_OPLINE
5456
602
  zval *array_ptr, *result;
5457
5458
602
  SAVE_OPLINE();
5459
5460
602
  array_ptr = RT_CONSTANT(opline, opline->op1);
5461
602
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5462
597
    result = EX_VAR(opline->result.var);
5463
597
    ZVAL_COPY_VALUE(result, array_ptr);
5464
597
    if (IS_CONST != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
5465
0
      Z_ADDREF_P(array_ptr);
5466
0
    }
5467
597
    Z_FE_POS_P(result) = 0;
5468
5469
597
    ZEND_VM_NEXT_OPCODE();
5470
597
  } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5471
0
    zend_object *zobj = Z_OBJ_P(array_ptr);
5472
0
    if (!zobj->ce->get_iterator) {
5473
0
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
5474
0
        zobj = zend_lazy_object_init(zobj);
5475
0
        if (UNEXPECTED(EG(exception))) {
5476
0
          UNDEF_RESULT();
5477
5478
0
          HANDLE_EXCEPTION();
5479
0
        }
5480
0
      }
5481
0
      HashTable *properties = zobj->properties;
5482
0
      if (properties) {
5483
0
        if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
5484
0
          if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
5485
0
            GC_DELREF(properties);
5486
0
          }
5487
0
          properties = zobj->properties = zend_array_dup(properties);
5488
0
        }
5489
0
      } else {
5490
0
        properties = zobj->handlers->get_properties(zobj);
5491
0
      }
5492
5493
0
      result = EX_VAR(opline->result.var);
5494
0
      ZVAL_COPY_VALUE(result, array_ptr);
5495
0
      if (IS_CONST != IS_TMP_VAR) {
5496
0
        Z_ADDREF_P(array_ptr);
5497
0
      }
5498
5499
0
      if (zend_hash_num_elements(properties) == 0) {
5500
0
        Z_FE_ITER_P(result) = (uint32_t) -1;
5501
5502
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5503
0
      }
5504
5505
0
      Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
5506
5507
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5508
0
    } else {
5509
0
      bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
5510
5511
0
      if (UNEXPECTED(EG(exception))) {
5512
0
        HANDLE_EXCEPTION();
5513
0
      } else if (is_empty) {
5514
0
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5515
0
      } else {
5516
0
        ZEND_VM_NEXT_OPCODE();
5517
0
      }
5518
0
    }
5519
5
  } else {
5520
5
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5521
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
5522
5
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5523
5524
5
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5525
5
  }
5526
602
}
5527
5528
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5529
102
{
5530
102
  USE_OPLINE
5531
102
  zval *array_ptr, *array_ref;
5532
5533
102
  SAVE_OPLINE();
5534
5535
102
  if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5536
0
    array_ref = array_ptr = zend_get_bad_ptr();
5537
0
    if (Z_ISREF_P(array_ref)) {
5538
0
      array_ptr = Z_REFVAL_P(array_ref);
5539
0
    }
5540
102
  } else {
5541
102
    array_ref = array_ptr = RT_CONSTANT(opline, opline->op1);
5542
102
  }
5543
5544
102
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5545
102
    if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5546
0
      if (array_ptr == array_ref) {
5547
0
        ZVAL_NEW_REF(array_ref, array_ref);
5548
0
        array_ptr = Z_REFVAL_P(array_ref);
5549
0
      }
5550
0
      Z_ADDREF_P(array_ref);
5551
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5552
102
    } else {
5553
102
      array_ref = EX_VAR(opline->result.var);
5554
102
      ZVAL_NEW_REF(array_ref, array_ptr);
5555
102
      array_ptr = Z_REFVAL_P(array_ref);
5556
102
    }
5557
102
    if (IS_CONST == IS_CONST) {
5558
102
      ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
5559
102
    } else {
5560
0
      SEPARATE_ARRAY(array_ptr);
5561
0
    }
5562
102
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
5563
5564
102
    ZEND_VM_NEXT_OPCODE();
5565
102
  } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5566
0
    if (!Z_OBJCE_P(array_ptr)->get_iterator) {
5567
0
      zend_object *zobj = Z_OBJ_P(array_ptr);
5568
0
      HashTable *properties;
5569
0
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
5570
0
        zobj = zend_lazy_object_init(zobj);
5571
0
        if (UNEXPECTED(EG(exception))) {
5572
0
          UNDEF_RESULT();
5573
5574
0
          HANDLE_EXCEPTION();
5575
0
        }
5576
0
      }
5577
0
      if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5578
0
        if (array_ptr == array_ref) {
5579
0
          ZVAL_NEW_REF(array_ref, array_ref);
5580
0
          array_ptr = Z_REFVAL_P(array_ref);
5581
0
        }
5582
0
        Z_ADDREF_P(array_ref);
5583
0
        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5584
0
      } else {
5585
0
        array_ptr = EX_VAR(opline->result.var);
5586
0
        ZVAL_COPY_VALUE(array_ptr, array_ref);
5587
0
      }
5588
0
      if (Z_OBJ_P(array_ptr)->properties
5589
0
       && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
5590
0
        if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
5591
0
          GC_DELREF(Z_OBJ_P(array_ptr)->properties);
5592
0
        }
5593
0
        Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
5594
0
      }
5595
5596
0
      properties = Z_OBJPROP_P(array_ptr);
5597
0
      if (zend_hash_num_elements(properties) == 0) {
5598
0
        Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
5599
5600
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5601
0
      }
5602
5603
0
      Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
5604
5605
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5606
0
    } else {
5607
0
      bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
5608
5609
0
      if (UNEXPECTED(EG(exception))) {
5610
0
        HANDLE_EXCEPTION();
5611
0
      } else if (is_empty) {
5612
0
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5613
0
      } else {
5614
0
        ZEND_VM_NEXT_OPCODE();
5615
0
      }
5616
0
    }
5617
0
  } else {
5618
0
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5619
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
5620
0
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5621
5622
0
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5623
0
  }
5624
102
}
5625
5626
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5627
50
{
5628
50
  USE_OPLINE
5629
50
  zval *value;
5630
50
  zend_reference *ref = NULL;
5631
50
  bool ret;
5632
5633
50
  SAVE_OPLINE();
5634
50
  value = RT_CONSTANT(opline, opline->op1);
5635
5636
50
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) {
5637
0
    if (IS_CONST == IS_VAR) {
5638
0
      ref = Z_REF_P(value);
5639
0
    }
5640
0
    value = Z_REFVAL_P(value);
5641
0
  }
5642
5643
50
  ret = i_zend_is_true(value);
5644
5645
50
  if (UNEXPECTED(EG(exception))) {
5646
5647
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
5648
0
    HANDLE_EXCEPTION();
5649
0
  }
5650
5651
50
  if (ret) {
5652
29
    zval *result = EX_VAR(opline->result.var);
5653
5654
29
    ZVAL_COPY_VALUE(result, value);
5655
29
    if (IS_CONST == IS_CONST) {
5656
29
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5657
29
    } else if (IS_CONST == IS_CV) {
5658
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5659
0
    } else if (IS_CONST == IS_VAR && ref) {
5660
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5661
0
        efree_size(ref, sizeof(zend_reference));
5662
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
5663
0
        Z_ADDREF_P(result);
5664
0
      }
5665
0
    }
5666
29
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5667
29
  }
5668
5669
21
  ZEND_VM_NEXT_OPCODE();
5670
21
}
5671
5672
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5673
58
{
5674
58
  USE_OPLINE
5675
58
  zval *value;
5676
58
  zend_reference *ref = NULL;
5677
5678
58
  SAVE_OPLINE();
5679
58
  value = RT_CONSTANT(opline, opline->op1);
5680
5681
58
  if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
5682
0
    if (IS_CONST & IS_VAR) {
5683
0
      ref = Z_REF_P(value);
5684
0
    }
5685
0
    value = Z_REFVAL_P(value);
5686
0
  }
5687
5688
58
  if (Z_TYPE_P(value) > IS_NULL) {
5689
43
    zval *result = EX_VAR(opline->result.var);
5690
43
    ZVAL_COPY_VALUE(result, value);
5691
43
    if (IS_CONST == IS_CONST) {
5692
43
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5693
43
    } else if (IS_CONST == IS_CV) {
5694
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5695
0
    } else if ((IS_CONST & IS_VAR) && ref) {
5696
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5697
0
        efree_size(ref, sizeof(zend_reference));
5698
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
5699
0
        Z_ADDREF_P(result);
5700
0
      }
5701
0
    }
5702
43
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5703
43
  }
5704
5705
15
  if ((IS_CONST & IS_VAR) && ref) {
5706
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5707
0
      efree_size(ref, sizeof(zend_reference));
5708
0
    }
5709
0
  }
5710
15
  ZEND_VM_NEXT_OPCODE();
5711
15
}
5712
5713
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5714
201
{
5715
201
  USE_OPLINE
5716
201
  zval *val, *result;
5717
5718
201
  val = RT_CONSTANT(opline, opline->op1);
5719
5720
201
  if (Z_TYPE_P(val) > IS_NULL) {
5721
55
    do {
5722
55
      if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
5723
0
        val = Z_REFVAL_P(val);
5724
0
        if (Z_TYPE_P(val) <= IS_NULL) {
5725
5726
0
          break;
5727
0
        }
5728
0
      }
5729
55
      ZEND_VM_NEXT_OPCODE();
5730
55
    } while (0);
5731
55
  }
5732
5733
146
  result = EX_VAR(opline->result.var);
5734
146
  uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
5735
146
  if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
5736
146
    ZVAL_NULL(result);
5737
146
    if (IS_CONST == IS_CV
5738
146
      && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
5739
146
      && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
5740
146
    ) {
5741
0
      SAVE_OPLINE();
5742
0
      ZVAL_UNDEFINED_OP1();
5743
0
      if (UNEXPECTED(EG(exception) != NULL)) {
5744
0
        HANDLE_EXCEPTION();
5745
0
      }
5746
0
    }
5747
146
  } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
5748
0
    ZVAL_FALSE(result);
5749
0
  } else {
5750
0
    ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
5751
0
    ZVAL_TRUE(result);
5752
0
  }
5753
5754
146
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5755
146
}
5756
5757
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5758
1
{
5759
1
  USE_OPLINE
5760
1
  zval *value;
5761
1
  zval *result = EX_VAR(opline->result.var);
5762
5763
1
  value = RT_CONSTANT(opline, opline->op1);
5764
1
  if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5765
0
    SAVE_OPLINE();
5766
0
    ZVAL_UNDEFINED_OP1();
5767
0
    ZVAL_NULL(result);
5768
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5769
0
  }
5770
5771
1
  if (IS_CONST == IS_CV) {
5772
0
    ZVAL_COPY_DEREF(result, value);
5773
1
  } else if (IS_CONST == IS_VAR) {
5774
0
    if (UNEXPECTED(Z_ISREF_P(value))) {
5775
0
      ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
5776
0
      if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
5777
0
        efree_size(Z_REF_P(value), sizeof(zend_reference));
5778
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
5779
0
        Z_ADDREF_P(result);
5780
0
      }
5781
0
    } else {
5782
0
      ZVAL_COPY_VALUE(result, value);
5783
0
    }
5784
1
  } else {
5785
1
    ZVAL_COPY_VALUE(result, value);
5786
1
    if (IS_CONST == IS_CONST) {
5787
1
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
5788
0
        Z_ADDREF_P(result);
5789
0
      }
5790
1
    }
5791
1
  }
5792
1
  ZEND_VM_NEXT_OPCODE();
5793
1
}
5794
5795
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5796
5.88k
{
5797
5.88k
  USE_OPLINE
5798
5799
5.88k
  SAVE_OPLINE();
5800
5.88k
  do_bind_class(RT_CONSTANT(opline, opline->op1), (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL);
5801
5.88k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5802
5.88k
}
5803
5804
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5805
10.3k
{
5806
10.3k
  USE_OPLINE
5807
10.3k
  zend_function *func;
5808
10.3k
  zval *object;
5809
10.3k
  zend_class_entry *called_scope;
5810
5811
10.3k
  func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
5812
10.3k
  if (Z_TYPE(EX(This)) == IS_OBJECT) {
5813
2.14k
    called_scope = Z_OBJCE(EX(This));
5814
2.14k
    if (UNEXPECTED((func->common.fn_flags & ZEND_ACC_STATIC) ||
5815
2.14k
        (EX(func)->common.fn_flags & ZEND_ACC_STATIC))) {
5816
47
      object = NULL;
5817
2.10k
    } else {
5818
2.10k
      object = &EX(This);
5819
2.10k
    }
5820
8.16k
  } else {
5821
8.16k
    called_scope = Z_CE(EX(This));
5822
8.16k
    object = NULL;
5823
8.16k
  }
5824
10.3k
  SAVE_OPLINE();
5825
10.3k
  zend_create_closure(EX_VAR(opline->result.var), func,
5826
10.3k
    EX(func)->op_array.scope, called_scope, object);
5827
5828
10.3k
  ZEND_VM_NEXT_OPCODE();
5829
10.3k
}
5830
5831
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5832
44
{
5833
44
  USE_OPLINE
5834
44
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
5835
44
  zval *val;
5836
5837
44
  SAVE_OPLINE();
5838
44
  val = RT_CONSTANT(opline, opline->op1);
5839
5840
44
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
5841
0
    zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
5842
5843
0
    UNDEF_RESULT();
5844
0
    HANDLE_EXCEPTION();
5845
0
  }
5846
5847
44
yield_from_try_again:
5848
44
  if (Z_TYPE_P(val) == IS_ARRAY) {
5849
44
    ZVAL_COPY_VALUE(&generator->values, val);
5850
44
    if (Z_OPT_REFCOUNTED_P(val)) {
5851
0
      Z_ADDREF_P(val);
5852
0
    }
5853
44
    Z_FE_POS(generator->values) = 0;
5854
5855
44
  } else if (IS_CONST != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
5856
0
    zend_class_entry *ce = Z_OBJCE_P(val);
5857
0
    if (ce == zend_ce_generator) {
5858
0
      zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
5859
5860
0
      Z_ADDREF_P(val);
5861
5862
0
      if (UNEXPECTED(new_gen->execute_data == NULL)) {
5863
0
        zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
5864
0
        zval_ptr_dtor(val);
5865
0
        UNDEF_RESULT();
5866
0
        HANDLE_EXCEPTION();
5867
0
      } else if (Z_ISUNDEF(new_gen->retval)) {
5868
0
        if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
5869
0
          zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
5870
0
          zval_ptr_dtor(val);
5871
0
          UNDEF_RESULT();
5872
0
          HANDLE_EXCEPTION();
5873
0
        } else {
5874
0
          zend_generator_yield_from(generator, new_gen);
5875
0
        }
5876
0
      } else {
5877
0
        if (RETURN_VALUE_USED(opline)) {
5878
0
          ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
5879
0
        }
5880
0
        ZEND_VM_NEXT_OPCODE();
5881
0
      }
5882
0
    } else {
5883
0
      zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
5884
5885
0
      if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
5886
0
        if (!EG(exception)) {
5887
0
          zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
5888
0
        }
5889
0
        UNDEF_RESULT();
5890
0
        HANDLE_EXCEPTION();
5891
0
      }
5892
5893
0
      iter->index = 0;
5894
0
      if (iter->funcs->rewind) {
5895
0
        iter->funcs->rewind(iter);
5896
0
        if (UNEXPECTED(EG(exception) != NULL)) {
5897
0
          OBJ_RELEASE(&iter->std);
5898
0
          UNDEF_RESULT();
5899
0
          HANDLE_EXCEPTION();
5900
0
        }
5901
0
      }
5902
5903
0
      ZVAL_OBJ(&generator->values, &iter->std);
5904
0
    }
5905
0
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
5906
0
    val = Z_REFVAL_P(val);
5907
0
    goto yield_from_try_again;
5908
0
  } else {
5909
0
    zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
5910
5911
0
    UNDEF_RESULT();
5912
0
    HANDLE_EXCEPTION();
5913
0
  }
5914
5915
  /* This is the default return value
5916
   * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
5917
44
  if (RETURN_VALUE_USED(opline)) {
5918
44
    ZVAL_NULL(EX_VAR(opline->result.var));
5919
44
  }
5920
5921
  /* This generator has no send target (though the generator we delegate to might have one) */
5922
44
  generator->send_target = NULL;
5923
5924
  /* The GOTO VM uses a local opline variable. We need to set the opline
5925
   * variable in execute_data so we don't resume at an old position. */
5926
44
  SAVE_OPLINE();
5927
5928
44
  ZEND_VM_RETURN();
5929
44
}
5930
5931
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5932
10
{
5933
10
  USE_OPLINE
5934
10
  zval *value;
5935
5936
10
  value = RT_CONSTANT(opline, opline->op1);
5937
10
  if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5938
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5939
0
    if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
5940
0
      zval_ptr_dtor_str(value);
5941
0
    }
5942
0
    ZEND_VM_NEXT_OPCODE();
5943
10
  } else {
5944
10
    bool strict;
5945
5946
10
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
5947
0
      value = Z_REFVAL_P(value);
5948
0
      if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5949
0
        ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5950
5951
0
        ZEND_VM_NEXT_OPCODE();
5952
0
      }
5953
0
    }
5954
5955
10
    SAVE_OPLINE();
5956
10
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5957
0
      value = ZVAL_UNDEFINED_OP1();
5958
0
    }
5959
10
    strict = EX_USES_STRICT_TYPES();
5960
10
    do {
5961
10
      if (EXPECTED(!strict)) {
5962
5
        zend_string *str;
5963
5
        zval tmp;
5964
5965
5
        if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
5966
3
          zend_error(E_DEPRECATED,
5967
3
            "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
5968
3
          ZVAL_LONG(EX_VAR(opline->result.var), 0);
5969
3
          if (UNEXPECTED(EG(exception))) {
5970
0
            HANDLE_EXCEPTION();
5971
0
          }
5972
3
          break;
5973
3
        }
5974
5975
2
        ZVAL_COPY(&tmp, value);
5976
2
        if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
5977
2
          ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
5978
2
          zval_ptr_dtor(&tmp);
5979
2
          break;
5980
2
        }
5981
0
        zval_ptr_dtor(&tmp);
5982
0
      }
5983
5
      if (!EG(exception)) {
5984
5
        zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
5985
5
      }
5986
5
      ZVAL_UNDEF(EX_VAR(opline->result.var));
5987
5
    } while (0);
5988
10
  }
5989
5990
10
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5991
10
}
5992
5993
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5994
44
{
5995
44
  USE_OPLINE
5996
44
  zval *value;
5997
44
  int result = 0;
5998
5999
44
  value = RT_CONSTANT(opline, opline->op1);
6000
44
  if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
6001
26
type_check_resource:
6002
26
    if (opline->extended_value != MAY_BE_RESOURCE
6003
26
     || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
6004
26
      result = 1;
6005
26
    }
6006
26
  } else if ((IS_CONST & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
6007
0
    value = Z_REFVAL_P(value);
6008
0
    if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
6009
0
      goto type_check_resource;
6010
0
    }
6011
18
  } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
6012
0
    result = ((1 << IS_NULL) & opline->extended_value) != 0;
6013
0
    SAVE_OPLINE();
6014
0
    ZVAL_UNDEFINED_OP1();
6015
0
    if (UNEXPECTED(EG(exception))) {
6016
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
6017
0
      HANDLE_EXCEPTION();
6018
0
    }
6019
0
  }
6020
44
  if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6021
0
    SAVE_OPLINE();
6022
6023
0
    ZEND_VM_SMART_BRANCH(result, 1);
6024
44
  } else {
6025
44
    ZEND_VM_SMART_BRANCH(result, 0);
6026
44
  }
6027
44
}
6028
6029
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6030
1.85k
{
6031
1.85k
  USE_OPLINE
6032
1.85k
  zend_constant *c;
6033
6034
1.85k
  c = CACHED_PTR(opline->extended_value);
6035
1.85k
  if (EXPECTED(c != NULL)) {
6036
1.79k
    if (!IS_SPECIAL_CACHE_VAL(c)) {
6037
34
defined_true:
6038
34
      ZEND_VM_SMART_BRANCH_TRUE();
6039
1.78k
    } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
6040
1.82k
defined_false:
6041
1.82k
      ZEND_VM_SMART_BRANCH_FALSE();
6042
1.82k
    }
6043
1.79k
  }
6044
69
  if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
6045
48
    CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
6046
48
    goto defined_false;
6047
48
  } else {
6048
21
    goto defined_true;
6049
21
  }
6050
69
}
6051
6052
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6053
0
{
6054
0
  USE_OPLINE
6055
0
  zend_jmp_fl_result result = (uintptr_t)CACHED_PTR(opline->extended_value);
6056
0
try_again:
6057
0
  if (EXPECTED(result == ZEND_JMP_FL_HIT)) {
6058
0
    OPLINE = OP_JMP_ADDR(opline, opline->op2);
6059
0
    ZEND_VM_CONTINUE();
6060
0
  } else if (EXPECTED(result == ZEND_JMP_FL_MISS)) {
6061
0
    ZEND_VM_NEXT_OPCODE();
6062
0
  } else {
6063
0
    ZEND_ASSERT(result == ZEND_JMP_FL_UNPRIMED);
6064
    /* func_name refers to the function in the local namespace, e.g. foo\substr. */
6065
0
    zval *func_name = (zval *)RT_CONSTANT(opline, opline->op1);
6066
    /* If it cannot be found locally, we must be referring to the global function. */
6067
0
    zval *func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name));
6068
    /* ZEND_JMP_FL_MISS = 1, ZEND_JMP_FL_HIT = 2 */
6069
0
    result = (func == NULL) + 1;
6070
0
    CACHE_PTR(opline->extended_value, (void *)result);
6071
0
    goto try_again;
6072
0
  }
6073
0
}
6074
6075
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6076
0
{
6077
0
  USE_OPLINE
6078
0
  zval *value;
6079
6080
0
  value = RT_CONSTANT(opline, opline->op1);
6081
0
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
6082
0
  ZEND_VM_NEXT_OPCODE();
6083
0
}
6084
6085
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6086
0
{
6087
0
  USE_OPLINE
6088
0
  zval *value;
6089
6090
0
  value = RT_CONSTANT(opline, opline->op1);
6091
0
  ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
6092
0
  ZEND_VM_NEXT_OPCODE();
6093
0
}
6094
6095
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6096
16.6k
{
6097
16.6k
  USE_OPLINE
6098
16.6k
  zval *value;
6099
6100
16.6k
  value = RT_CONSTANT(opline, opline->op1);
6101
16.6k
  ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
6102
16.6k
  ZEND_VM_NEXT_OPCODE();
6103
16.6k
}
6104
6105
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6106
68.4k
{
6107
68.4k
  USE_OPLINE
6108
68.4k
  zval *value, *arg;
6109
6110
68.4k
  value = RT_CONSTANT(opline, opline->op1);
6111
68.4k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
6112
68.4k
  ZVAL_COPY_VALUE(arg, value);
6113
68.4k
  ZEND_VM_NEXT_OPCODE();
6114
68.4k
}
6115
6116
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6117
87.3k
{
6118
87.3k
  USE_OPLINE
6119
87.3k
  zval *value, *arg;
6120
87.3k
  uint32_t arg_num = opline->op2.num;
6121
6122
87.3k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
6123
87.3k
  if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
6124
27
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
6125
27
  }
6126
87.2k
  value = RT_CONSTANT(opline, opline->op1);
6127
87.2k
  ZVAL_COPY_VALUE(arg, value);
6128
87.2k
  ZEND_VM_NEXT_OPCODE();
6129
87.2k
}
6130
6131
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6132
519
{
6133
519
  USE_OPLINE
6134
519
  zval *op1, *op2, *result;
6135
519
  double d1, d2;
6136
6137
519
  op1 = RT_CONSTANT(opline, opline->op1);
6138
519
  op2 = RT_CONSTANT(opline, opline->op2);
6139
519
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6140
    /* pass */
6141
519
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6142
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6143
0
      result = EX_VAR(opline->result.var);
6144
0
      fast_long_add_function(result, op1, op2);
6145
0
      ZEND_VM_NEXT_OPCODE();
6146
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6147
0
      d1 = (double)Z_LVAL_P(op1);
6148
0
      d2 = Z_DVAL_P(op2);
6149
0
      goto add_double;
6150
0
    }
6151
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6152
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6153
0
      d1 = Z_DVAL_P(op1);
6154
0
      d2 = Z_DVAL_P(op2);
6155
0
add_double:
6156
0
      result = EX_VAR(opline->result.var);
6157
0
      ZVAL_DOUBLE(result, d1 + d2);
6158
0
      ZEND_VM_NEXT_OPCODE();
6159
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6160
0
      d1 = Z_DVAL_P(op1);
6161
0
      d2 = (double)Z_LVAL_P(op2);
6162
0
      goto add_double;
6163
0
    }
6164
0
  }
6165
6166
519
  ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6167
519
}
6168
6169
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6170
618
{
6171
618
  USE_OPLINE
6172
618
  zval *op1, *op2, *result;
6173
618
  double d1, d2;
6174
6175
618
  op1 = RT_CONSTANT(opline, opline->op1);
6176
618
  op2 = RT_CONSTANT(opline, opline->op2);
6177
618
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6178
    /* pass */
6179
618
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6180
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6181
0
      result = EX_VAR(opline->result.var);
6182
0
      fast_long_sub_function(result, op1, op2);
6183
0
      ZEND_VM_NEXT_OPCODE();
6184
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6185
0
      d1 = (double)Z_LVAL_P(op1);
6186
0
      d2 = Z_DVAL_P(op2);
6187
0
      goto sub_double;
6188
0
    }
6189
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6190
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6191
0
      d1 = Z_DVAL_P(op1);
6192
0
      d2 = Z_DVAL_P(op2);
6193
0
sub_double:
6194
0
      result = EX_VAR(opline->result.var);
6195
0
      ZVAL_DOUBLE(result, d1 - d2);
6196
0
      ZEND_VM_NEXT_OPCODE();
6197
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6198
0
      d1 = Z_DVAL_P(op1);
6199
0
      d2 = (double)Z_LVAL_P(op2);
6200
0
      goto sub_double;
6201
0
    }
6202
0
  }
6203
6204
618
  ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6205
618
}
6206
6207
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6208
4.84k
{
6209
4.84k
  USE_OPLINE
6210
4.84k
  zval *op1, *op2, *result;
6211
4.84k
  double d1, d2;
6212
6213
4.84k
  op1 = RT_CONSTANT(opline, opline->op1);
6214
4.84k
  op2 = RT_CONSTANT(opline, opline->op2);
6215
4.84k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6216
    /* pass */
6217
4.84k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6218
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6219
0
      zend_long overflow;
6220
6221
0
      result = EX_VAR(opline->result.var);
6222
0
      ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
6223
0
      Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
6224
0
      ZEND_VM_NEXT_OPCODE();
6225
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6226
0
      d1 = (double)Z_LVAL_P(op1);
6227
0
      d2 = Z_DVAL_P(op2);
6228
0
      goto mul_double;
6229
0
    }
6230
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6231
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6232
0
      d1 = Z_DVAL_P(op1);
6233
0
      d2 = Z_DVAL_P(op2);
6234
0
mul_double:
6235
0
      result = EX_VAR(opline->result.var);
6236
0
      ZVAL_DOUBLE(result, d1 * d2);
6237
0
      ZEND_VM_NEXT_OPCODE();
6238
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6239
0
      d1 = Z_DVAL_P(op1);
6240
0
      d2 = (double)Z_LVAL_P(op2);
6241
0
      goto mul_double;
6242
0
    }
6243
0
  }
6244
6245
4.84k
  ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6246
4.84k
}
6247
6248
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6249
838
{
6250
838
  USE_OPLINE
6251
838
  zval *op1, *op2;
6252
6253
838
  SAVE_OPLINE();
6254
838
  op1 = RT_CONSTANT(opline, opline->op1);
6255
838
  op2 = RT_CONSTANT(opline, opline->op2);
6256
838
  div_function(EX_VAR(opline->result.var), op1, op2);
6257
6258
6259
838
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6260
838
}
6261
6262
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6263
19.1k
{
6264
19.1k
  USE_OPLINE
6265
19.1k
  zval *op1, *op2, *result;
6266
6267
19.1k
  op1 = RT_CONSTANT(opline, opline->op1);
6268
19.1k
  op2 = RT_CONSTANT(opline, opline->op2);
6269
19.1k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6270
    /* pass */
6271
19.1k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6272
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6273
0
      result = EX_VAR(opline->result.var);
6274
0
      if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
6275
0
        ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6276
0
      } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
6277
        /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
6278
0
        ZVAL_LONG(result, 0);
6279
0
      } else {
6280
0
        ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
6281
0
      }
6282
0
      ZEND_VM_NEXT_OPCODE();
6283
0
    }
6284
0
  }
6285
6286
19.1k
  ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6287
19.1k
}
6288
6289
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6290
1.95k
{
6291
1.95k
  USE_OPLINE
6292
1.95k
  zval *op1, *op2;
6293
6294
1.95k
  op1 = RT_CONSTANT(opline, opline->op1);
6295
1.95k
  op2 = RT_CONSTANT(opline, opline->op2);
6296
1.95k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6297
    /* pass */
6298
1.95k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6299
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6300
0
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6301
    /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
6302
0
    ZVAL_LONG(EX_VAR(opline->result.var),
6303
0
      (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
6304
0
    ZEND_VM_NEXT_OPCODE();
6305
0
  }
6306
6307
1.95k
  ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6308
1.95k
}
6309
6310
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6311
621
{
6312
621
  USE_OPLINE
6313
621
  zval *op1, *op2;
6314
6315
621
  op1 = RT_CONSTANT(opline, opline->op1);
6316
621
  op2 = RT_CONSTANT(opline, opline->op2);
6317
621
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6318
    /* pass */
6319
621
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6320
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6321
0
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6322
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
6323
0
    ZEND_VM_NEXT_OPCODE();
6324
0
  }
6325
6326
621
  ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6327
621
}
6328
6329
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6330
433
{
6331
433
  USE_OPLINE
6332
433
  zval *op1, *op2;
6333
6334
433
  SAVE_OPLINE();
6335
433
  op1 = RT_CONSTANT(opline, opline->op1);
6336
433
  op2 = RT_CONSTANT(opline, opline->op2);
6337
433
  pow_function(EX_VAR(opline->result.var), op1, op2);
6338
6339
6340
433
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6341
433
}
6342
6343
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6344
49
{
6345
49
  USE_OPLINE
6346
49
  zval *op1, *op2;
6347
49
  bool result;
6348
6349
49
  SAVE_OPLINE();
6350
49
  op1 = RT_CONSTANT(opline, opline->op1);
6351
49
  op2 = RT_CONSTANT(opline, opline->op2);
6352
49
  result = fast_is_identical_function(op1, op2);
6353
6354
6355
49
  ZEND_VM_SMART_BRANCH(result, 1);
6356
49
}
6357
6358
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6359
2
{
6360
2
  USE_OPLINE
6361
2
  zval *op1, *op2;
6362
2
  bool result;
6363
6364
2
  SAVE_OPLINE();
6365
2
  op1 = RT_CONSTANT(opline, opline->op1);
6366
2
  op2 = RT_CONSTANT(opline, opline->op2);
6367
2
  result = fast_is_not_identical_function(op1, op2);
6368
6369
6370
2
  ZEND_VM_SMART_BRANCH(result, 1);
6371
2
}
6372
6373
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6374
84
{
6375
84
  USE_OPLINE
6376
84
  zval *op1, *op2;
6377
84
  double d1, d2;
6378
6379
84
  op1 = RT_CONSTANT(opline, opline->op1);
6380
84
  op2 = RT_CONSTANT(opline, opline->op2);
6381
84
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6382
    /* pass */
6383
84
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6384
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6385
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
6386
0
is_equal_true:
6387
0
        ZEND_VM_SMART_BRANCH_TRUE();
6388
0
      } else {
6389
0
is_equal_false:
6390
0
        ZEND_VM_SMART_BRANCH_FALSE();
6391
0
      }
6392
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6393
0
      d1 = (double)Z_LVAL_P(op1);
6394
0
      d2 = Z_DVAL_P(op2);
6395
0
      goto is_equal_double;
6396
0
    }
6397
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6398
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6399
0
      d1 = Z_DVAL_P(op1);
6400
0
      d2 = Z_DVAL_P(op2);
6401
0
is_equal_double:
6402
0
      if (d1 == d2) {
6403
0
        goto is_equal_true;
6404
0
      } else {
6405
0
        goto is_equal_false;
6406
0
      }
6407
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6408
0
      d1 = Z_DVAL_P(op1);
6409
0
      d2 = (double)Z_LVAL_P(op2);
6410
0
      goto is_equal_double;
6411
0
    }
6412
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6413
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6414
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6415
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6416
0
        zval_ptr_dtor_str(op1);
6417
0
      }
6418
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6419
0
        zval_ptr_dtor_str(op2);
6420
0
      }
6421
0
      if (result) {
6422
0
        goto is_equal_true;
6423
0
      } else {
6424
0
        goto is_equal_false;
6425
0
      }
6426
0
    }
6427
0
  }
6428
84
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6429
84
}
6430
6431
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6432
0
{
6433
0
  USE_OPLINE
6434
0
  zval *op1, *op2;
6435
0
  double d1, d2;
6436
6437
0
  op1 = RT_CONSTANT(opline, opline->op1);
6438
0
  op2 = RT_CONSTANT(opline, opline->op2);
6439
0
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6440
    /* pass */
6441
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6442
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6443
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
6444
0
is_not_equal_true:
6445
0
        ZEND_VM_SMART_BRANCH_TRUE();
6446
0
      } else {
6447
0
is_not_equal_false:
6448
0
        ZEND_VM_SMART_BRANCH_FALSE();
6449
0
      }
6450
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6451
0
      d1 = (double)Z_LVAL_P(op1);
6452
0
      d2 = Z_DVAL_P(op2);
6453
0
      goto is_not_equal_double;
6454
0
    }
6455
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6456
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6457
0
      d1 = Z_DVAL_P(op1);
6458
0
      d2 = Z_DVAL_P(op2);
6459
0
is_not_equal_double:
6460
0
      if (d1 != d2) {
6461
0
        goto is_not_equal_true;
6462
0
      } else {
6463
0
        goto is_not_equal_false;
6464
0
      }
6465
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6466
0
      d1 = Z_DVAL_P(op1);
6467
0
      d2 = (double)Z_LVAL_P(op2);
6468
0
      goto is_not_equal_double;
6469
0
    }
6470
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6471
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6472
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6473
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6474
0
        zval_ptr_dtor_str(op1);
6475
0
      }
6476
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6477
0
        zval_ptr_dtor_str(op2);
6478
0
      }
6479
0
      if (!result) {
6480
0
        goto is_not_equal_true;
6481
0
      } else {
6482
0
        goto is_not_equal_false;
6483
0
      }
6484
0
    }
6485
0
  }
6486
0
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6487
0
}
6488
6489
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6490
92
{
6491
92
  USE_OPLINE
6492
92
  zval *op1, *op2;
6493
92
  double d1, d2;
6494
6495
92
  op1 = RT_CONSTANT(opline, opline->op1);
6496
92
  op2 = RT_CONSTANT(opline, opline->op2);
6497
92
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6498
    /* pass */
6499
92
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6500
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6501
0
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
6502
0
is_smaller_true:
6503
0
        ZEND_VM_SMART_BRANCH_TRUE();
6504
0
      } else {
6505
0
is_smaller_false:
6506
0
        ZEND_VM_SMART_BRANCH_FALSE();
6507
0
      }
6508
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6509
0
      d1 = (double)Z_LVAL_P(op1);
6510
0
      d2 = Z_DVAL_P(op2);
6511
0
      goto is_smaller_double;
6512
0
    }
6513
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6514
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6515
0
      d1 = Z_DVAL_P(op1);
6516
0
      d2 = Z_DVAL_P(op2);
6517
0
is_smaller_double:
6518
0
      if (d1 < d2) {
6519
0
        goto is_smaller_true;
6520
0
      } else {
6521
0
        goto is_smaller_false;
6522
0
      }
6523
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6524
0
      d1 = Z_DVAL_P(op1);
6525
0
      d2 = (double)Z_LVAL_P(op2);
6526
0
      goto is_smaller_double;
6527
0
    }
6528
0
  }
6529
92
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6530
92
}
6531
6532
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6533
0
{
6534
0
  USE_OPLINE
6535
0
  zval *op1, *op2;
6536
0
  double d1, d2;
6537
6538
0
  op1 = RT_CONSTANT(opline, opline->op1);
6539
0
  op2 = RT_CONSTANT(opline, opline->op2);
6540
0
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6541
    /* pass */
6542
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6543
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6544
0
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
6545
0
is_smaller_or_equal_true:
6546
0
        ZEND_VM_SMART_BRANCH_TRUE();
6547
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
6548
0
        ZEND_VM_NEXT_OPCODE();
6549
0
      } else {
6550
0
is_smaller_or_equal_false:
6551
0
        ZEND_VM_SMART_BRANCH_FALSE();
6552
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
6553
0
        ZEND_VM_NEXT_OPCODE();
6554
0
      }
6555
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6556
0
      d1 = (double)Z_LVAL_P(op1);
6557
0
      d2 = Z_DVAL_P(op2);
6558
0
      goto is_smaller_or_equal_double;
6559
0
    }
6560
0
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6561
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6562
0
      d1 = Z_DVAL_P(op1);
6563
0
      d2 = Z_DVAL_P(op2);
6564
0
is_smaller_or_equal_double:
6565
0
      if (d1 <= d2) {
6566
0
        goto is_smaller_or_equal_true;
6567
0
      } else {
6568
0
        goto is_smaller_or_equal_false;
6569
0
      }
6570
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6571
0
      d1 = Z_DVAL_P(op1);
6572
0
      d2 = (double)Z_LVAL_P(op2);
6573
0
      goto is_smaller_or_equal_double;
6574
0
    }
6575
0
  }
6576
0
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6577
0
}
6578
6579
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6580
0
{
6581
0
  USE_OPLINE
6582
0
  zval *op1, *op2;
6583
6584
0
  SAVE_OPLINE();
6585
0
  op1 = RT_CONSTANT(opline, opline->op1);
6586
0
  op2 = RT_CONSTANT(opline, opline->op2);
6587
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
6588
6589
6590
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6591
0
}
6592
6593
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6594
1.44k
{
6595
1.44k
  USE_OPLINE
6596
1.44k
  zval *op1, *op2;
6597
6598
1.44k
  op1 = RT_CONSTANT(opline, opline->op1);
6599
1.44k
  op2 = RT_CONSTANT(opline, opline->op2);
6600
1.44k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6601
    /* pass */
6602
1.44k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6603
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6604
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
6605
0
    ZEND_VM_NEXT_OPCODE();
6606
0
  }
6607
6608
1.44k
  ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6609
1.44k
}
6610
6611
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6612
1.41k
{
6613
1.41k
  USE_OPLINE
6614
1.41k
  zval *op1, *op2;
6615
6616
1.41k
  op1 = RT_CONSTANT(opline, opline->op1);
6617
1.41k
  op2 = RT_CONSTANT(opline, opline->op2);
6618
1.41k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6619
    /* pass */
6620
1.41k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6621
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6622
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
6623
0
    ZEND_VM_NEXT_OPCODE();
6624
0
  }
6625
6626
1.41k
  ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6627
1.41k
}
6628
6629
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6630
31.5k
{
6631
31.5k
  USE_OPLINE
6632
31.5k
  zval *op1, *op2;
6633
6634
31.5k
  op1 = RT_CONSTANT(opline, opline->op1);
6635
31.5k
  op2 = RT_CONSTANT(opline, opline->op2);
6636
31.5k
  if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6637
    /* pass */
6638
31.5k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6639
0
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6640
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
6641
0
    ZEND_VM_NEXT_OPCODE();
6642
0
  }
6643
6644
31.5k
  ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
6645
31.5k
}
6646
6647
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6648
0
{
6649
0
  USE_OPLINE
6650
0
  zval *op1, *op2;
6651
6652
0
  SAVE_OPLINE();
6653
0
  op1 = RT_CONSTANT(opline, opline->op1);
6654
0
  op2 = RT_CONSTANT(opline, opline->op2);
6655
0
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
6656
6657
6658
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6659
0
}
6660
6661
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6662
449
{
6663
449
  USE_OPLINE
6664
449
  zval *container, *dim, *value;
6665
6666
449
  SAVE_OPLINE();
6667
449
  container = RT_CONSTANT(opline, opline->op1);
6668
449
  dim = RT_CONSTANT(opline, opline->op2);
6669
449
  if (IS_CONST != IS_CONST) {
6670
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6671
0
fetch_dim_r_array:
6672
0
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
6673
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
6674
0
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
6675
0
      container = Z_REFVAL_P(container);
6676
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6677
0
        goto fetch_dim_r_array;
6678
0
      } else {
6679
0
        goto fetch_dim_r_slow;
6680
0
      }
6681
0
    } else {
6682
0
fetch_dim_r_slow:
6683
0
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
6684
0
        dim++;
6685
0
      }
6686
0
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
6687
0
    }
6688
449
  } else {
6689
449
    zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6690
449
  }
6691
6692
6693
449
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6694
449
}
6695
6696
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6697
3
{
6698
3
  USE_OPLINE
6699
3
  zval *container;
6700
6701
3
  SAVE_OPLINE();
6702
3
  container = RT_CONSTANT(opline, opline->op1);
6703
3
  zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6704
6705
6706
3
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6707
3
}
6708
6709
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6710
19
{
6711
#if 0
6712
  USE_OPLINE
6713
#endif
6714
6715
19
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
6716
5
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
6717
5
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6718
5
    }
6719
5
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6720
14
  } else {
6721
14
    if (IS_CONST == IS_UNUSED) {
6722
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6723
0
    }
6724
14
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6725
14
  }
6726
19
}
6727
6728
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6729
69
{
6730
69
  USE_OPLINE
6731
69
  zval *container;
6732
69
  void **cache_slot = NULL;
6733
6734
69
  SAVE_OPLINE();
6735
69
  container = RT_CONSTANT(opline, opline->op1);
6736
6737
69
  if (IS_CONST == IS_CONST ||
6738
69
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6739
69
    do {
6740
69
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6741
0
        container = Z_REFVAL_P(container);
6742
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6743
0
          break;
6744
0
        }
6745
0
      }
6746
69
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
6747
0
        ZVAL_UNDEFINED_OP1();
6748
0
      }
6749
69
      zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
6750
69
      ZVAL_NULL(EX_VAR(opline->result.var));
6751
69
      goto fetch_obj_r_finish;
6752
69
    } while (0);
6753
69
  }
6754
6755
  /* here we are sure we are dealing with an object */
6756
0
  do {
6757
0
    zend_object *zobj = Z_OBJ_P(container);
6758
0
    zend_string *name, *tmp_name;
6759
0
    zval *retval;
6760
6761
0
    if (IS_CONST == IS_CONST) {
6762
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
6763
6764
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6765
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6766
6767
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6768
0
fetch_obj_r_simple:
6769
0
          retval = OBJ_PROP(zobj, prop_offset);
6770
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
6771
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6772
0
              goto fetch_obj_r_copy;
6773
0
            } else {
6774
0
fetch_obj_r_fast_copy:
6775
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6776
0
              ZEND_VM_NEXT_OPCODE();
6777
0
            }
6778
0
          }
6779
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
6780
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
6781
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
6782
0
            prop_offset = prop_info->offset;
6783
0
            goto fetch_obj_r_simple;
6784
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
6785
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
6786
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
6787
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
6788
6789
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
6790
0
            if (IS_CONST & IS_CV) {
6791
0
              GC_ADDREF(zobj);
6792
0
            }
6793
0
            if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
6794
0
              call_info |= ZEND_CALL_RELEASE_THIS;
6795
0
            }
6796
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
6797
0
            call->prev_execute_data = execute_data;
6798
0
            call->call = NULL;
6799
0
            call->return_value = EX_VAR(opline->result.var);
6800
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
6801
6802
0
            execute_data = call;
6803
0
            EG(current_execute_data) = execute_data;
6804
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
6805
6806
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
6807
            opline = hook->op_array.opcodes;
6808
#else
6809
0
            EX(opline) = hook->op_array.opcodes;
6810
0
#endif
6811
0
            LOAD_OPLINE_EX();
6812
6813
6814
0
            ZEND_VM_ENTER_EX();
6815
0
          }
6816
          /* Fall through to read_property for hooks. */
6817
0
        } else if (EXPECTED(zobj->properties != NULL)) {
6818
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
6819
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6820
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6821
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6822
6823
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6824
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6825
6826
0
              if (EXPECTED(p->key == name) ||
6827
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
6828
0
                   EXPECTED(p->key != NULL) &&
6829
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
6830
0
                retval = &p->val;
6831
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6832
0
                  goto fetch_obj_r_copy;
6833
0
                } else {
6834
0
                  goto fetch_obj_r_fast_copy;
6835
0
                }
6836
0
              }
6837
0
            }
6838
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6839
0
          }
6840
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
6841
0
          if (EXPECTED(retval)) {
6842
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6843
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6844
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6845
0
              goto fetch_obj_r_copy;
6846
0
            } else {
6847
0
              goto fetch_obj_r_fast_copy;
6848
0
            }
6849
0
          }
6850
0
        }
6851
0
      }
6852
0
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6853
0
    } else {
6854
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6855
0
      if (UNEXPECTED(!name)) {
6856
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
6857
0
        break;
6858
0
      }
6859
0
    }
6860
6861
0
#if ZEND_DEBUG
6862
    /* For non-standard object handlers, verify a declared property type in debug builds.
6863
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
6864
0
    zend_property_info *prop_info = NULL;
6865
0
    if (zobj->handlers->read_property != zend_std_read_property) {
6866
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
6867
0
    }
6868
0
#endif
6869
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
6870
0
#if ZEND_DEBUG
6871
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
6872
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
6873
0
      ZVAL_OPT_DEREF(retval);
6874
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
6875
0
    }
6876
0
#endif
6877
6878
0
    if (IS_CONST != IS_CONST) {
6879
0
      zend_tmp_string_release(tmp_name);
6880
0
    }
6881
6882
0
    if (retval != EX_VAR(opline->result.var)) {
6883
0
fetch_obj_r_copy:
6884
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6885
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
6886
0
      zend_unwrap_reference(retval);
6887
0
    }
6888
0
  } while (0);
6889
6890
69
fetch_obj_r_finish:
6891
6892
6893
69
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6894
69
}
6895
6896
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6897
5
{
6898
5
  USE_OPLINE
6899
5
  zval *container;
6900
5
  void **cache_slot = NULL;
6901
6902
5
  SAVE_OPLINE();
6903
5
  container = RT_CONSTANT(opline, opline->op1);
6904
6905
5
  if (IS_CONST == IS_CONST ||
6906
5
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6907
5
    do {
6908
5
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6909
0
        container = Z_REFVAL_P(container);
6910
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6911
0
          break;
6912
0
        }
6913
0
      }
6914
5
      if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
6915
0
        ZVAL_UNDEFINED_OP2();
6916
0
      }
6917
5
      ZVAL_NULL(EX_VAR(opline->result.var));
6918
5
      goto fetch_obj_is_finish;
6919
5
    } while (0);
6920
5
  }
6921
6922
  /* here we are sure we are dealing with an object */
6923
0
  do {
6924
0
    zend_object *zobj = Z_OBJ_P(container);
6925
0
    zend_string *name, *tmp_name;
6926
0
    zval *retval;
6927
6928
0
    if (IS_CONST == IS_CONST) {
6929
0
      cache_slot = CACHE_ADDR(opline->extended_value);
6930
6931
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6932
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6933
6934
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6935
0
fetch_obj_is_simple:
6936
0
          retval = OBJ_PROP(zobj, prop_offset);
6937
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
6938
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6939
0
              goto fetch_obj_is_copy;
6940
0
            } else {
6941
0
fetch_obj_is_fast_copy:
6942
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6943
0
              ZEND_VM_NEXT_OPCODE();
6944
0
            }
6945
0
          }
6946
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
6947
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
6948
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
6949
0
            prop_offset = prop_info->offset;
6950
0
            goto fetch_obj_is_simple;
6951
0
          }
6952
          /* Fall through to read_property for hooks. */
6953
0
        } else if (EXPECTED(zobj->properties != NULL)) {
6954
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
6955
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6956
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6957
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6958
6959
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6960
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6961
6962
0
              if (EXPECTED(p->key == name) ||
6963
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
6964
0
                   EXPECTED(p->key != NULL) &&
6965
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
6966
0
                retval = &p->val;
6967
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6968
0
                  goto fetch_obj_is_copy;
6969
0
                } else {
6970
0
                  goto fetch_obj_is_fast_copy;
6971
0
                }
6972
0
              }
6973
0
            }
6974
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6975
0
          }
6976
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
6977
0
          if (EXPECTED(retval)) {
6978
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6979
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6980
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6981
0
              goto fetch_obj_is_copy;
6982
0
            } else {
6983
0
              goto fetch_obj_is_fast_copy;
6984
0
            }
6985
0
          }
6986
0
        }
6987
0
      }
6988
0
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6989
0
    } else {
6990
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6991
0
      if (UNEXPECTED(!name)) {
6992
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
6993
0
        break;
6994
0
      }
6995
0
    }
6996
6997
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
6998
6999
0
    if (IS_CONST != IS_CONST) {
7000
0
      zend_tmp_string_release(tmp_name);
7001
0
    }
7002
7003
0
    if (retval != EX_VAR(opline->result.var)) {
7004
0
fetch_obj_is_copy:
7005
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
7006
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
7007
0
      zend_unwrap_reference(retval);
7008
0
    }
7009
0
  } while (0);
7010
7011
5
fetch_obj_is_finish:
7012
7013
7014
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7015
5
}
7016
7017
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7018
5
{
7019
#if 0
7020
  USE_OPLINE
7021
#endif
7022
7023
5
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
7024
    /* Behave like FETCH_OBJ_W */
7025
5
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
7026
5
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7027
5
    }
7028
5
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7029
5
  } else {
7030
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7031
0
  }
7032
5
}
7033
7034
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7035
90
{
7036
90
  USE_OPLINE
7037
90
  zval *container;
7038
7039
90
  SAVE_OPLINE();
7040
90
  container = RT_CONSTANT(opline, opline->op1);
7041
90
  zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
7042
7043
90
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7044
90
}
7045
7046
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7047
196
{
7048
196
  USE_OPLINE
7049
196
  zval *op1, *op2;
7050
196
  zend_string *op1_str, *op2_str, *str;
7051
7052
7053
196
  op1 = RT_CONSTANT(opline, opline->op1);
7054
196
  op2 = RT_CONSTANT(opline, opline->op2);
7055
196
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
7056
196
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
7057
196
    zend_string *op1_str = Z_STR_P(op1);
7058
196
    zend_string *op2_str = Z_STR_P(op2);
7059
196
    zend_string *str;
7060
196
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
7061
7062
196
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
7063
0
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
7064
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
7065
0
      } else {
7066
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
7067
0
      }
7068
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7069
0
        zend_string_release_ex(op1_str, 0);
7070
0
      }
7071
196
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
7072
0
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
7073
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
7074
0
      } else {
7075
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
7076
0
      }
7077
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7078
0
        zend_string_release_ex(op2_str, 0);
7079
0
      }
7080
196
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
7081
196
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
7082
0
      size_t len = ZSTR_LEN(op1_str);
7083
7084
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
7085
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7086
0
      GC_ADD_FLAGS(str, flags);
7087
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7088
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7089
0
        zend_string_release_ex(op2_str, 0);
7090
0
      }
7091
196
    } else {
7092
196
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
7093
196
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
7094
196
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7095
196
      GC_ADD_FLAGS(str, flags);
7096
196
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7097
196
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7098
0
        zend_string_release_ex(op1_str, 0);
7099
0
      }
7100
196
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7101
0
        zend_string_release_ex(op2_str, 0);
7102
0
      }
7103
196
    }
7104
196
    ZEND_VM_NEXT_OPCODE();
7105
196
  }
7106
7107
196
  SAVE_OPLINE();
7108
0
  if (IS_CONST == IS_CONST) {
7109
0
    op1_str = Z_STR_P(op1);
7110
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
7111
0
    op1_str = zend_string_copy(Z_STR_P(op1));
7112
0
  } else {
7113
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
7114
0
      ZVAL_UNDEFINED_OP1();
7115
0
    }
7116
0
    op1_str = zval_get_string_func(op1);
7117
0
  }
7118
0
  if (IS_CONST == IS_CONST) {
7119
0
    op2_str = Z_STR_P(op2);
7120
0
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
7121
0
    op2_str = zend_string_copy(Z_STR_P(op2));
7122
0
  } else {
7123
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
7124
0
      ZVAL_UNDEFINED_OP2();
7125
0
    }
7126
0
    op2_str = zval_get_string_func(op2);
7127
0
  }
7128
0
  do {
7129
0
    if (IS_CONST != IS_CONST) {
7130
0
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
7131
0
        if (IS_CONST == IS_CONST) {
7132
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
7133
0
            GC_ADDREF(op2_str);
7134
0
          }
7135
0
        }
7136
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
7137
0
        zend_string_release_ex(op1_str, 0);
7138
0
        break;
7139
0
      }
7140
0
    }
7141
0
    if (IS_CONST != IS_CONST) {
7142
0
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
7143
0
        if (IS_CONST == IS_CONST) {
7144
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
7145
0
            GC_ADDREF(op1_str);
7146
0
          }
7147
0
        }
7148
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
7149
0
        zend_string_release_ex(op2_str, 0);
7150
0
        break;
7151
0
      }
7152
0
    }
7153
0
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
7154
0
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
7155
0
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7156
7157
0
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
7158
0
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7159
0
    if (IS_CONST != IS_CONST) {
7160
0
      zend_string_release_ex(op1_str, 0);
7161
0
    }
7162
0
    if (IS_CONST != IS_CONST) {
7163
0
      zend_string_release_ex(op2_str, 0);
7164
0
    }
7165
0
  } while (0);
7166
7167
7168
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7169
0
}
7170
7171
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7172
77
{
7173
77
  USE_OPLINE
7174
77
  zval *function_name;
7175
77
  zval *object;
7176
77
  zend_function *fbc;
7177
77
  zend_class_entry *called_scope;
7178
77
  zend_object *obj;
7179
77
  zend_execute_data *call;
7180
77
  uint32_t call_info;
7181
7182
77
  SAVE_OPLINE();
7183
7184
77
  object = RT_CONSTANT(opline, opline->op1);
7185
7186
77
  if (IS_CONST != IS_CONST) {
7187
0
    function_name = RT_CONSTANT(opline, opline->op2);
7188
0
  }
7189
7190
77
  if (IS_CONST != IS_CONST &&
7191
77
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7192
0
    do {
7193
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
7194
0
        function_name = Z_REFVAL_P(function_name);
7195
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
7196
0
          break;
7197
0
        }
7198
0
      } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
7199
0
        ZVAL_UNDEFINED_OP2();
7200
0
        if (UNEXPECTED(EG(exception) != NULL)) {
7201
7202
0
          HANDLE_EXCEPTION();
7203
0
        }
7204
0
      }
7205
0
      zend_throw_error(NULL, "Method name must be a string");
7206
7207
7208
0
      HANDLE_EXCEPTION();
7209
0
    } while (0);
7210
0
  }
7211
7212
77
  if (IS_CONST == IS_UNUSED) {
7213
0
    obj = Z_OBJ_P(object);
7214
77
  } else {
7215
77
    do {
7216
77
      if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
7217
0
        obj = Z_OBJ_P(object);
7218
77
      } else {
7219
77
        if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
7220
0
          zend_reference *ref = Z_REF_P(object);
7221
7222
0
          object = &ref->val;
7223
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
7224
0
            obj = Z_OBJ_P(object);
7225
0
            if (IS_CONST & IS_VAR) {
7226
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7227
0
                efree_size(ref, sizeof(zend_reference));
7228
0
              } else {
7229
0
                Z_ADDREF_P(object);
7230
0
              }
7231
0
            }
7232
0
            break;
7233
0
          }
7234
0
        }
7235
77
        if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
7236
0
          object = ZVAL_UNDEFINED_OP1();
7237
0
          if (UNEXPECTED(EG(exception) != NULL)) {
7238
0
            if (IS_CONST != IS_CONST) {
7239
7240
0
            }
7241
0
            HANDLE_EXCEPTION();
7242
0
          }
7243
0
        }
7244
77
        if (IS_CONST == IS_CONST) {
7245
77
          function_name = RT_CONSTANT(opline, opline->op2);
7246
77
        }
7247
77
        zend_invalid_method_call(object, function_name);
7248
7249
7250
77
        HANDLE_EXCEPTION();
7251
77
      }
7252
77
    } while (0);
7253
77
  }
7254
7255
0
  called_scope = obj->ce;
7256
7257
0
  if (IS_CONST == IS_CONST &&
7258
0
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
7259
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
7260
0
  } else {
7261
0
    zend_object *orig_obj = obj;
7262
7263
0
    if (IS_CONST == IS_CONST) {
7264
0
      function_name = RT_CONSTANT(opline, opline->op2);
7265
0
    }
7266
7267
    /* First, locate the function. */
7268
0
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
7269
0
    if (UNEXPECTED(fbc == NULL)) {
7270
0
      if (EXPECTED(!EG(exception))) {
7271
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
7272
0
      }
7273
7274
0
      if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
7275
0
        zend_objects_store_del(orig_obj);
7276
0
      }
7277
0
      HANDLE_EXCEPTION();
7278
0
    }
7279
0
    if (IS_CONST == IS_CONST &&
7280
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7281
0
        EXPECTED(obj == orig_obj)) {
7282
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
7283
0
    }
7284
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
7285
0
      GC_ADDREF(obj); /* For $this pointer */
7286
0
      if (GC_DELREF(orig_obj) == 0) {
7287
0
        zend_objects_store_del(orig_obj);
7288
0
      }
7289
0
    }
7290
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7291
0
      init_func_run_time_cache(&fbc->op_array);
7292
0
    }
7293
0
  }
7294
7295
0
  if (IS_CONST != IS_CONST) {
7296
7297
0
  }
7298
7299
0
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7300
0
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
7301
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
7302
0
      zend_objects_store_del(obj);
7303
0
      if (UNEXPECTED(EG(exception))) {
7304
0
        HANDLE_EXCEPTION();
7305
0
      }
7306
0
    }
7307
    /* call static method */
7308
0
    obj = (zend_object*)called_scope;
7309
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
7310
0
  } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
7311
0
    if (IS_CONST == IS_CV) {
7312
0
      GC_ADDREF(obj); /* For $this pointer */
7313
0
    }
7314
    /* CV may be changed indirectly (e.g. when it's a reference) */
7315
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
7316
0
  }
7317
7318
0
  call = zend_vm_stack_push_call_frame(call_info,
7319
0
    fbc, opline->extended_value, obj);
7320
0
  call->prev_execute_data = EX(call);
7321
0
  EX(call) = call;
7322
7323
0
  ZEND_VM_NEXT_OPCODE();
7324
0
}
7325
7326
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7327
6.62k
{
7328
6.62k
  USE_OPLINE
7329
6.62k
  zval *function_name;
7330
6.62k
  zend_class_entry *ce;
7331
6.62k
  uint32_t call_info;
7332
6.62k
  zend_function *fbc;
7333
6.62k
  zend_execute_data *call;
7334
7335
6.62k
  SAVE_OPLINE();
7336
7337
6.62k
  if (IS_CONST == IS_CONST) {
7338
    /* no function found. try a static method in class */
7339
6.62k
    ce = CACHED_PTR(opline->result.num);
7340
6.62k
    if (UNEXPECTED(ce == NULL)) {
7341
4.39k
      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);
7342
4.39k
      if (UNEXPECTED(ce == NULL)) {
7343
7344
95
        HANDLE_EXCEPTION();
7345
95
      }
7346
4.29k
      if (IS_CONST != IS_CONST) {
7347
0
        CACHE_PTR(opline->result.num, ce);
7348
0
      }
7349
4.29k
    }
7350
6.62k
  } else if (IS_CONST == IS_UNUSED) {
7351
0
    ce = zend_fetch_class(NULL, opline->op1.num);
7352
0
    if (UNEXPECTED(ce == NULL)) {
7353
7354
0
      HANDLE_EXCEPTION();
7355
0
    }
7356
0
  } else {
7357
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
7358
0
  }
7359
7360
6.53k
  if (IS_CONST == IS_CONST &&
7361
6.53k
      IS_CONST == IS_CONST &&
7362
6.53k
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
7363
    /* nothing to do */
7364
4.29k
  } else if (IS_CONST != IS_CONST &&
7365
4.29k
             IS_CONST == IS_CONST &&
7366
4.29k
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
7367
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
7368
4.29k
  } else if (IS_CONST != IS_UNUSED) {
7369
4.29k
    function_name = RT_CONSTANT(opline, opline->op2);
7370
4.29k
    if (IS_CONST != IS_CONST) {
7371
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7372
0
        do {
7373
0
          if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
7374
0
            function_name = Z_REFVAL_P(function_name);
7375
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
7376
0
              break;
7377
0
            }
7378
0
          } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
7379
0
            ZVAL_UNDEFINED_OP2();
7380
0
            if (UNEXPECTED(EG(exception) != NULL)) {
7381
0
              HANDLE_EXCEPTION();
7382
0
            }
7383
0
          }
7384
0
          zend_throw_error(NULL, "Method name must be a string");
7385
7386
0
          HANDLE_EXCEPTION();
7387
0
        } while (0);
7388
0
      }
7389
0
    }
7390
7391
4.29k
    if (ce->get_static_method) {
7392
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
7393
4.29k
    } else {
7394
4.29k
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
7395
4.29k
    }
7396
4.29k
    if (UNEXPECTED(fbc == NULL)) {
7397
125
      if (EXPECTED(!EG(exception))) {
7398
72
        zend_undefined_method(ce, Z_STR_P(function_name));
7399
72
      }
7400
7401
125
      HANDLE_EXCEPTION();
7402
125
    }
7403
4.16k
    if (IS_CONST == IS_CONST &&
7404
4.16k
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7405
4.16k
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
7406
3.53k
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
7407
3.53k
    }
7408
4.16k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7409
1.93k
      init_func_run_time_cache(&fbc->op_array);
7410
1.93k
    }
7411
4.16k
    if (IS_CONST != IS_CONST) {
7412
7413
0
    }
7414
4.16k
  } else {
7415
5
    if (UNEXPECTED(ce->constructor == NULL)) {
7416
0
      zend_throw_error(NULL, "Cannot call constructor");
7417
0
      HANDLE_EXCEPTION();
7418
0
    }
7419
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)) {
7420
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
7421
0
      HANDLE_EXCEPTION();
7422
0
    }
7423
5
    fbc = ce->constructor;
7424
5
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7425
0
      init_func_run_time_cache(&fbc->op_array);
7426
0
    }
7427
5
  }
7428
7429
6.40k
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
7430
222
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
7431
207
      ce = (zend_class_entry*)Z_OBJ(EX(This));
7432
207
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7433
207
    } else {
7434
15
      zend_non_static_method_call(fbc);
7435
15
      HANDLE_EXCEPTION();
7436
15
    }
7437
6.18k
  } else {
7438
    /* previous opcode is ZEND_FETCH_CLASS */
7439
6.18k
    if (IS_CONST == IS_UNUSED
7440
6.18k
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
7441
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
7442
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
7443
0
        ce = Z_OBJCE(EX(This));
7444
0
      } else {
7445
0
        ce = Z_CE(EX(This));
7446
0
      }
7447
0
    }
7448
6.18k
    call_info = ZEND_CALL_NESTED_FUNCTION;
7449
6.18k
  }
7450
7451
6.39k
  call = zend_vm_stack_push_call_frame(call_info,
7452
6.39k
    fbc, opline->extended_value, ce);
7453
6.39k
  call->prev_execute_data = EX(call);
7454
6.39k
  EX(call) = call;
7455
7456
6.39k
  ZEND_VM_NEXT_OPCODE();
7457
6.39k
}
7458
7459
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7460
618
{
7461
618
  USE_OPLINE
7462
618
  zval *function_name;
7463
618
  zend_fcall_info_cache fcc;
7464
618
  char *error = NULL;
7465
618
  zend_function *func;
7466
618
  void *object_or_called_scope;
7467
618
  zend_execute_data *call;
7468
618
  uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
7469
7470
618
  SAVE_OPLINE();
7471
618
  function_name = RT_CONSTANT(opline, opline->op2);
7472
618
  if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
7473
578
    ZEND_ASSERT(!error);
7474
7475
    /* Deprecation can be emitted from zend_is_callable_ex(), which can
7476
     * invoke a user error handler and throw an exception.
7477
     * For the CONST and CV case we reuse the same exception block below
7478
     * to make sure we don't increase VM size too much. */
7479
578
    if (!(IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7480
7481
0
      HANDLE_EXCEPTION();
7482
0
    }
7483
7484
578
    func = fcc.function_handler;
7485
578
    object_or_called_scope = fcc.called_scope;
7486
578
    if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
7487
      /* Delay closure destruction until its invocation */
7488
0
      GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
7489
0
      call_info |= ZEND_CALL_CLOSURE;
7490
0
      if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
7491
0
        call_info |= ZEND_CALL_FAKE_CLOSURE;
7492
0
      }
7493
0
      if (fcc.object) {
7494
0
        object_or_called_scope = fcc.object;
7495
0
        call_info |= ZEND_CALL_HAS_THIS;
7496
0
      }
7497
578
    } else if (fcc.object) {
7498
314
      GC_ADDREF(fcc.object); /* For $this pointer */
7499
314
      object_or_called_scope = fcc.object;
7500
314
      call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
7501
314
    }
7502
7503
578
    if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7504
0
      if (call_info & ZEND_CALL_CLOSURE) {
7505
0
        zend_object_release(ZEND_CLOSURE_OBJECT(func));
7506
0
      } else if (call_info & ZEND_CALL_RELEASE_THIS) {
7507
0
        zend_object_release(fcc.object);
7508
0
      }
7509
0
      HANDLE_EXCEPTION();
7510
0
    }
7511
7512
578
    if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
7513
65
      init_func_run_time_cache(&func->op_array);
7514
65
    }
7515
578
  } else {
7516
40
    zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
7517
40
    efree(error);
7518
7519
40
    HANDLE_EXCEPTION();
7520
40
  }
7521
7522
578
  call = zend_vm_stack_push_call_frame(call_info,
7523
578
    func, opline->extended_value, object_or_called_scope);
7524
578
  call->prev_execute_data = EX(call);
7525
578
  EX(call) = call;
7526
7527
578
  ZEND_VM_NEXT_OPCODE();
7528
578
}
7529
7530
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7531
409
{
7532
409
  USE_OPLINE
7533
409
  zval *value, *arg;
7534
7535
409
  if (IS_CONST == IS_CONST) {
7536
409
    SAVE_OPLINE();
7537
409
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7538
409
    uint32_t arg_num;
7539
409
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7540
409
    if (UNEXPECTED(!arg)) {
7541
7542
15
      HANDLE_EXCEPTION();
7543
15
    }
7544
409
  } else {
7545
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7546
0
  }
7547
7548
394
  value = RT_CONSTANT(opline, opline->op1);
7549
394
  ZVAL_COPY_VALUE(arg, value);
7550
394
  if (IS_CONST == IS_CONST) {
7551
394
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7552
0
      Z_ADDREF_P(arg);
7553
0
    }
7554
394
  }
7555
394
  ZEND_VM_NEXT_OPCODE();
7556
394
}
7557
7558
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7559
949
{
7560
949
  USE_OPLINE
7561
949
  zval *value, *arg;
7562
949
  uint32_t arg_num;
7563
7564
949
  if (IS_CONST == IS_CONST) {
7565
949
    SAVE_OPLINE();
7566
949
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7567
949
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7568
949
    if (UNEXPECTED(!arg)) {
7569
7570
63
      HANDLE_EXCEPTION();
7571
63
    }
7572
949
  } else {
7573
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7574
0
    arg_num = opline->op2.num;
7575
0
  }
7576
7577
886
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
7578
886
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7579
5
      goto send_val_by_ref;
7580
5
    }
7581
886
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7582
5
send_val_by_ref:
7583
5
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
7584
0
  }
7585
881
  value = RT_CONSTANT(opline, opline->op1);
7586
881
  ZVAL_COPY_VALUE(arg, value);
7587
881
  if (IS_CONST == IS_CONST) {
7588
881
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7589
0
      Z_ADDREF_P(arg);
7590
0
    }
7591
881
  }
7592
881
  ZEND_VM_NEXT_OPCODE();
7593
881
}
7594
7595
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7596
2.68k
{
7597
2.68k
  zend_class_entry *ce, *scope;
7598
2.68k
  zend_class_constant *c;
7599
2.68k
  zval *value, *zv, *constant_zv;
7600
2.68k
  zend_string *constant_name;
7601
2.68k
  USE_OPLINE
7602
7603
2.68k
  SAVE_OPLINE();
7604
7605
2.68k
  do {
7606
2.68k
    if (IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
7607
2.68k
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
7608
640
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
7609
640
        break;
7610
640
      }
7611
2.68k
    }
7612
2.04k
    if (IS_CONST == IS_CONST) {
7613
2.04k
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
7614
58
        ce = CACHED_PTR(opline->extended_value);
7615
1.98k
      } else {
7616
1.98k
        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);
7617
1.98k
        if (UNEXPECTED(ce == NULL)) {
7618
88
          ZVAL_UNDEF(EX_VAR(opline->result.var));
7619
7620
88
          HANDLE_EXCEPTION();
7621
88
        }
7622
1.89k
        CACHE_PTR(opline->extended_value, ce);
7623
1.89k
      }
7624
2.04k
    } else if (IS_CONST == IS_UNUSED) {
7625
0
      ce = zend_fetch_class(NULL, opline->op1.num);
7626
0
      if (UNEXPECTED(ce == NULL)) {
7627
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
7628
7629
0
        HANDLE_EXCEPTION();
7630
0
      }
7631
0
    } else {
7632
0
      ce = Z_CE_P(EX_VAR(opline->op1.var));
7633
0
    }
7634
1.95k
    if (IS_CONST != IS_CONST
7635
1.95k
      && IS_CONST == IS_CONST
7636
1.95k
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
7637
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
7638
0
      break;
7639
0
    }
7640
7641
1.95k
    constant_zv = RT_CONSTANT(opline, opline->op2);
7642
1.95k
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
7643
46
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
7644
46
      ZVAL_UNDEF(EX_VAR(opline->result.var));
7645
7646
46
      HANDLE_EXCEPTION();
7647
46
    }
7648
1.90k
    constant_name = Z_STR_P(constant_zv);
7649
    /* Magic 'class' for constant OP2 is caught at compile-time */
7650
1.90k
    if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
7651
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
7652
7653
0
      ZEND_VM_NEXT_OPCODE();
7654
0
    }
7655
1.90k
    zv = IS_CONST == IS_CONST
7656
1.90k
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
7657
1.90k
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
7658
7659
1.90k
    if (EXPECTED(zv != NULL)) {
7660
1.81k
      c = Z_PTR_P(zv);
7661
1.81k
      scope = EX(func)->op_array.scope;
7662
1.81k
      if (!zend_verify_const_access(c, scope)) {
7663
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));
7664
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
7665
7666
5
        HANDLE_EXCEPTION();
7667
5
      }
7668
7669
1.81k
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
7670
5
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7671
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
7672
7673
5
        HANDLE_EXCEPTION();
7674
5
      }
7675
7676
1.80k
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
7677
1.80k
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
7678
50
        if (c->ce->type == ZEND_USER_CLASS) {
7679
          /* Recursion protection only applied to user constants, GH-18463 */
7680
50
          CONST_PROTECT_RECURSION(c);
7681
50
        }
7682
50
        zend_deprecated_class_constant(c, constant_name);
7683
50
        if (c->ce->type == ZEND_USER_CLASS) {
7684
50
          CONST_UNPROTECT_RECURSION(c);
7685
50
        }
7686
7687
50
        if (EG(exception)) {
7688
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
7689
7690
0
          HANDLE_EXCEPTION();
7691
0
        }
7692
50
      }
7693
7694
1.80k
      value = &c->value;
7695
      // Enums require loading of all class constants to build the backed enum table
7696
1.80k
      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)) {
7697
268
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
7698
63
          ZVAL_UNDEF(EX_VAR(opline->result.var));
7699
7700
63
          HANDLE_EXCEPTION();
7701
63
        }
7702
268
      }
7703
1.74k
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
7704
1.22k
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
7705
118
          ZVAL_UNDEF(EX_VAR(opline->result.var));
7706
7707
118
          HANDLE_EXCEPTION();
7708
118
        }
7709
1.22k
      }
7710
1.62k
      if (IS_CONST == IS_CONST && !is_constant_deprecated) {
7711
1.56k
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
7712
1.56k
      }
7713
1.62k
    } else {
7714
90
      zend_throw_error(NULL, "Undefined constant %s::%s",
7715
90
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7716
90
      ZVAL_UNDEF(EX_VAR(opline->result.var));
7717
7718
90
      HANDLE_EXCEPTION();
7719
90
    }
7720
1.90k
  } while (0);
7721
7722
2.26k
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
7723
7724
2.26k
  ZEND_VM_NEXT_OPCODE();
7725
2.26k
}
7726
7727
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7728
567
{
7729
567
  USE_OPLINE
7730
567
  zval *expr_ptr, new_expr;
7731
7732
567
  SAVE_OPLINE();
7733
567
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
7734
567
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
7735
0
    expr_ptr = zend_get_bad_ptr();
7736
0
    if (Z_ISREF_P(expr_ptr)) {
7737
0
      Z_ADDREF_P(expr_ptr);
7738
0
    } else {
7739
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
7740
0
    }
7741
7742
567
  } else {
7743
567
    expr_ptr = RT_CONSTANT(opline, opline->op1);
7744
567
    if (IS_CONST == IS_TMP_VAR) {
7745
      /* pass */
7746
567
    } else if (IS_CONST == IS_CONST) {
7747
567
      Z_TRY_ADDREF_P(expr_ptr);
7748
567
    } else if (IS_CONST == IS_CV) {
7749
0
      ZVAL_DEREF(expr_ptr);
7750
0
      Z_TRY_ADDREF_P(expr_ptr);
7751
0
    } else /* if (IS_CONST == IS_VAR) */ {
7752
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
7753
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
7754
7755
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
7756
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7757
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
7758
0
          expr_ptr = &new_expr;
7759
0
          efree_size(ref, sizeof(zend_reference));
7760
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
7761
0
          Z_ADDREF_P(expr_ptr);
7762
0
        }
7763
0
      }
7764
0
    }
7765
567
  }
7766
7767
567
  if (IS_CONST != IS_UNUSED) {
7768
567
    zval *offset = RT_CONSTANT(opline, opline->op2);
7769
567
    zend_string *str;
7770
567
    zend_ulong hval;
7771
7772
567
add_again:
7773
567
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7774
498
      str = Z_STR_P(offset);
7775
498
      if (IS_CONST != IS_CONST) {
7776
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
7777
0
          goto num_index;
7778
0
        }
7779
0
      }
7780
498
str_index:
7781
498
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
7782
498
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7783
38
      hval = Z_LVAL_P(offset);
7784
69
num_index:
7785
69
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
7786
69
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
7787
0
      offset = Z_REFVAL_P(offset);
7788
0
      goto add_again;
7789
31
    } else if (Z_TYPE_P(offset) == IS_NULL) {
7790
0
      str = ZSTR_EMPTY_ALLOC();
7791
0
      goto str_index;
7792
31
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
7793
26
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
7794
26
      goto num_index;
7795
26
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
7796
5
      hval = 0;
7797
5
      goto num_index;
7798
5
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
7799
0
      hval = 1;
7800
0
      goto num_index;
7801
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
7802
0
      zend_use_resource_as_offset(offset);
7803
0
      hval = Z_RES_HANDLE_P(offset);
7804
0
      goto num_index;
7805
0
    } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
7806
0
      ZVAL_UNDEFINED_OP2();
7807
0
      str = ZSTR_EMPTY_ALLOC();
7808
0
      goto str_index;
7809
0
    } else {
7810
0
      zend_illegal_array_offset_access(offset);
7811
0
      zval_ptr_dtor_nogc(expr_ptr);
7812
0
    }
7813
7814
567
  } else {
7815
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
7816
0
      zend_cannot_add_element();
7817
0
      zval_ptr_dtor_nogc(expr_ptr);
7818
0
    }
7819
0
  }
7820
567
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7821
567
}
7822
7823
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7824
105
{
7825
105
  zval *array;
7826
105
  uint32_t size;
7827
105
  USE_OPLINE
7828
7829
105
  SAVE_OPLINE();
7830
105
  array = EX_VAR(opline->result.var);
7831
105
  if (IS_CONST != IS_UNUSED) {
7832
105
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
7833
105
    ZVAL_ARR(array, zend_new_array(size));
7834
    /* Explicitly initialize array as not-packed if flag is set */
7835
105
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
7836
59
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
7837
59
    }
7838
105
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7839
105
  } else {
7840
0
    ZVAL_ARR(array, zend_new_array(0));
7841
0
    ZEND_VM_NEXT_OPCODE();
7842
0
  }
7843
105
}
7844
7845
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7846
5
{
7847
5
  USE_OPLINE
7848
5
  zval *container;
7849
5
  bool result;
7850
5
  zend_ulong hval;
7851
5
  zval *offset;
7852
7853
5
  SAVE_OPLINE();
7854
5
  container = RT_CONSTANT(opline, opline->op1);
7855
5
  offset = RT_CONSTANT(opline, opline->op2);
7856
7857
5
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7858
0
    HashTable *ht;
7859
0
    zval *value;
7860
0
    zend_string *str;
7861
7862
0
isset_dim_obj_array:
7863
0
    ht = Z_ARRVAL_P(container);
7864
0
isset_again:
7865
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7866
0
      str = Z_STR_P(offset);
7867
0
      if (IS_CONST != IS_CONST) {
7868
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
7869
0
          goto num_index_prop;
7870
0
        }
7871
0
      }
7872
0
      value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
7873
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7874
0
      hval = Z_LVAL_P(offset);
7875
0
num_index_prop:
7876
0
      value = zend_hash_index_find(ht, hval);
7877
0
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
7878
0
      offset = Z_REFVAL_P(offset);
7879
0
      goto isset_again;
7880
0
    } else {
7881
0
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
7882
0
      if (UNEXPECTED(EG(exception))) {
7883
0
        result = 0;
7884
0
        goto isset_dim_obj_exit;
7885
0
      }
7886
0
    }
7887
7888
0
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
7889
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
7890
0
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
7891
0
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
7892
7893
0
      if (IS_CONST & (IS_CONST|IS_CV)) {
7894
        /* avoid exception check */
7895
7896
0
        ZEND_VM_SMART_BRANCH(result, 0);
7897
0
      }
7898
0
    } else {
7899
0
      result = (value == NULL || !i_zend_is_true(value));
7900
0
    }
7901
0
    goto isset_dim_obj_exit;
7902
5
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
7903
0
    container = Z_REFVAL_P(container);
7904
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7905
0
      goto isset_dim_obj_array;
7906
0
    }
7907
0
  }
7908
7909
5
  if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
7910
0
    offset++;
7911
0
  }
7912
5
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
7913
2
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
7914
3
  } else {
7915
3
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
7916
3
  }
7917
7918
5
isset_dim_obj_exit:
7919
7920
7921
5
  ZEND_VM_SMART_BRANCH(result, 1);
7922
5
}
7923
7924
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7925
5
{
7926
5
  USE_OPLINE
7927
5
  zval *container;
7928
5
  int result;
7929
5
  zval *offset;
7930
5
  zend_string *name, *tmp_name;
7931
7932
5
  SAVE_OPLINE();
7933
5
  container = RT_CONSTANT(opline, opline->op1);
7934
5
  offset = RT_CONSTANT(opline, opline->op2);
7935
7936
5
  if (IS_CONST == IS_CONST ||
7937
5
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
7938
5
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
7939
0
      container = Z_REFVAL_P(container);
7940
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
7941
0
        result = (opline->extended_value & ZEND_ISEMPTY);
7942
0
        goto isset_object_finish;
7943
0
      }
7944
5
    } else {
7945
5
      result = (opline->extended_value & ZEND_ISEMPTY);
7946
5
      goto isset_object_finish;
7947
5
    }
7948
5
  }
7949
7950
0
  if (IS_CONST == IS_CONST) {
7951
0
    name = Z_STR_P(offset);
7952
0
  } else {
7953
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
7954
0
    if (UNEXPECTED(!name)) {
7955
0
      result = 0;
7956
0
      goto isset_object_finish;
7957
0
    }
7958
0
  }
7959
7960
0
  result =
7961
0
    (opline->extended_value & ZEND_ISEMPTY) ^
7962
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));
7963
7964
0
  if (IS_CONST != IS_CONST) {
7965
0
    zend_tmp_string_release(tmp_name);
7966
0
  }
7967
7968
5
isset_object_finish:
7969
7970
7971
5
  ZEND_VM_SMART_BRANCH(result, 1);
7972
5
}
7973
7974
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7975
0
{
7976
0
  USE_OPLINE
7977
7978
0
  zval *key, *subject;
7979
0
  HashTable *ht;
7980
0
  bool result;
7981
7982
0
  SAVE_OPLINE();
7983
7984
0
  key = RT_CONSTANT(opline, opline->op1);
7985
0
  subject = RT_CONSTANT(opline, opline->op2);
7986
7987
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7988
0
array_key_exists_array:
7989
0
    ht = Z_ARRVAL_P(subject);
7990
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
7991
0
  } else {
7992
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
7993
0
      subject = Z_REFVAL_P(subject);
7994
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7995
0
        goto array_key_exists_array;
7996
0
      }
7997
0
    }
7998
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
7999
0
    result = 0;
8000
0
  }
8001
8002
8003
0
  ZEND_VM_SMART_BRANCH(result, 1);
8004
0
}
8005
8006
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8007
677
{
8008
677
  USE_OPLINE
8009
8010
677
  zend_class_entry *ce = CACHED_PTR(opline->extended_value);
8011
677
  if (ce == NULL) {
8012
648
    zval *lcname = RT_CONSTANT(opline, opline->op1);
8013
648
    zval *zv = zend_hash_find_known_hash(EG(class_table), Z_STR_P(lcname + 1));
8014
648
    if (zv) {
8015
648
      SAVE_OPLINE();
8016
648
      ce = zend_bind_class_in_slot(zv, lcname, Z_STR_P(RT_CONSTANT(opline, opline->op2)));
8017
648
      if (!ce) {
8018
81
        HANDLE_EXCEPTION();
8019
81
      }
8020
648
    }
8021
567
    CACHE_PTR(opline->extended_value, ce);
8022
567
  }
8023
596
  ZEND_VM_NEXT_OPCODE();
8024
596
}
8025
8026
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8027
2.19k
{
8028
2.19k
  USE_OPLINE
8029
2.19k
  zval *name;
8030
2.19k
  zval *val;
8031
2.19k
  zend_constant c;
8032
8033
2.19k
  SAVE_OPLINE();
8034
2.19k
  name  = RT_CONSTANT(opline, opline->op1);
8035
2.19k
  val   = RT_CONSTANT(opline, opline->op2);
8036
8037
2.19k
  ZVAL_COPY(&c.value, val);
8038
2.19k
  if (Z_OPT_CONSTANT(c.value)) {
8039
1.09k
    if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
8040
182
      zval_ptr_dtor_nogc(&c.value);
8041
8042
8043
182
      HANDLE_EXCEPTION();
8044
182
    }
8045
1.09k
  }
8046
  /* non persistent, case sensitive */
8047
2.00k
  ZEND_CONSTANT_SET_FLAGS(&c, 0, PHP_USER_CONSTANT);
8048
2.00k
  c.name = zend_string_copy(Z_STR_P(name));
8049
8050
2.00k
  if (zend_register_constant(&c) == NULL) {
8051
22
  }
8052
8053
8054
2.00k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8055
2.00k
}
8056
8057
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8058
181
{
8059
181
  USE_OPLINE
8060
181
  zval *name;
8061
181
  zval *val;
8062
181
  zend_constant c, *registered;
8063
8064
181
  SAVE_OPLINE();
8065
181
  name  = RT_CONSTANT(opline, opline->op1);
8066
181
  val   = RT_CONSTANT(opline, opline->op2);
8067
8068
181
  ZVAL_COPY(&c.value, val);
8069
181
  if (Z_OPT_CONSTANT(c.value)) {
8070
13
    if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
8071
5
      zval_ptr_dtor_nogc(&c.value);
8072
8073
8074
5
      HANDLE_EXCEPTION();
8075
5
    }
8076
13
  }
8077
  /* non persistent, case sensitive */
8078
176
  ZEND_CONSTANT_SET_FLAGS(&c, 0, PHP_USER_CONSTANT);
8079
176
  c.name = zend_string_copy(Z_STR_P(name));
8080
8081
176
  registered = zend_register_constant(&c);
8082
176
  if (registered == NULL) {
8083
8084
8085
    /* two opcodes used, second one is the data with attributes */
8086
20
    ZEND_VM_NEXT_OPCODE_EX(1, 2);
8087
20
  }
8088
8089
156
  HashTable *attributes = Z_PTR_P(get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1));
8090
156
  ZEND_ASSERT(attributes != NULL);
8091
156
  zend_constant_add_attributes(registered, attributes);
8092
8093
8094
  /* two opcodes used, second one is the data with attributes */
8095
156
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
8096
156
}
8097
8098
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8099
144
{
8100
144
  USE_OPLINE
8101
8102
144
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
8103
8104
144
  SAVE_OPLINE();
8105
144
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
8106
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8107
0
  }
8108
8109
  /* Destroy the previously yielded value */
8110
144
  zval_ptr_dtor(&generator->value);
8111
8112
  /* Destroy the previously yielded key */
8113
144
  zval_ptr_dtor(&generator->key);
8114
8115
  /* Set the new yielded value */
8116
144
  if (IS_CONST != IS_UNUSED) {
8117
144
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
8118
      /* Constants and temporary variables aren't yieldable by reference,
8119
       * but we still allow them with a notice. */
8120
0
      if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
8121
0
        zval *value;
8122
8123
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
8124
8125
0
        value = RT_CONSTANT(opline, opline->op1);
8126
0
        ZVAL_COPY_VALUE(&generator->value, value);
8127
0
        if (IS_CONST == IS_CONST) {
8128
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
8129
0
            Z_ADDREF(generator->value);
8130
0
          }
8131
0
        }
8132
0
      } else {
8133
0
        zval *value_ptr = zend_get_bad_ptr();
8134
8135
        /* If a function call result is yielded and the function did
8136
         * not return by reference we throw a notice. */
8137
0
        do {
8138
0
          if (IS_CONST == IS_VAR) {
8139
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
8140
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
8141
0
             && !Z_ISREF_P(value_ptr)) {
8142
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
8143
0
              ZVAL_COPY(&generator->value, value_ptr);
8144
0
              break;
8145
0
            }
8146
0
          }
8147
0
          if (Z_ISREF_P(value_ptr)) {
8148
0
            Z_ADDREF_P(value_ptr);
8149
0
          } else {
8150
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
8151
0
          }
8152
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
8153
0
        } while (0);
8154
8155
0
      }
8156
144
    } else {
8157
144
      zval *value = RT_CONSTANT(opline, opline->op1);
8158
8159
      /* Consts, temporary variables and references need copying */
8160
144
      if (IS_CONST == IS_CONST) {
8161
144
        ZVAL_COPY_VALUE(&generator->value, value);
8162
144
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
8163
0
          Z_ADDREF(generator->value);
8164
0
        }
8165
144
      } else if (IS_CONST == IS_TMP_VAR) {
8166
0
        ZVAL_COPY_VALUE(&generator->value, value);
8167
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
8168
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
8169
8170
0
      } else {
8171
0
        ZVAL_COPY_VALUE(&generator->value, value);
8172
0
        if (IS_CONST == IS_CV) {
8173
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
8174
0
        }
8175
0
      }
8176
144
    }
8177
144
  } else {
8178
    /* If no value was specified yield null */
8179
0
    ZVAL_NULL(&generator->value);
8180
0
  }
8181
8182
  /* Set the new yielded key */
8183
144
  if (IS_CONST != IS_UNUSED) {
8184
144
    zval *key = RT_CONSTANT(opline, opline->op2);
8185
144
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
8186
0
      key = Z_REFVAL_P(key);
8187
0
    }
8188
144
    ZVAL_COPY(&generator->key, key);
8189
8190
144
    if (Z_TYPE(generator->key) == IS_LONG
8191
144
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
8192
144
    ) {
8193
6
      generator->largest_used_integer_key = Z_LVAL(generator->key);
8194
6
    }
8195
144
  } else {
8196
    /* If no key was specified we use auto-increment keys */
8197
0
    generator->largest_used_integer_key++;
8198
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
8199
0
  }
8200
8201
144
  if (RETURN_VALUE_USED(opline)) {
8202
    /* If the return value of yield is used set the send
8203
     * target and initialize it to NULL */
8204
48
    generator->send_target = EX_VAR(opline->result.var);
8205
48
    ZVAL_NULL(generator->send_target);
8206
96
  } else {
8207
96
    generator->send_target = NULL;
8208
96
  }
8209
8210
  /* The GOTO VM uses a local opline variable. We need to set the opline
8211
   * variable in execute_data so we don't resume at an old position. */
8212
144
  SAVE_OPLINE();
8213
8214
144
  ZEND_VM_RETURN();
8215
144
}
8216
8217
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8218
0
{
8219
0
  USE_OPLINE
8220
0
  zval *op, *jump_zv;
8221
0
  HashTable *jumptable;
8222
8223
0
  op = RT_CONSTANT(opline, opline->op1);
8224
8225
0
  if (Z_TYPE_P(op) != IS_LONG) {
8226
0
    ZVAL_DEREF(op);
8227
0
    if (Z_TYPE_P(op) != IS_LONG) {
8228
      /* Wrong type, fall back to ZEND_CASE chain */
8229
0
      ZEND_VM_NEXT_OPCODE();
8230
0
    }
8231
0
  }
8232
8233
0
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8234
0
  jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
8235
0
  if (jump_zv != NULL) {
8236
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8237
0
    ZEND_VM_CONTINUE();
8238
0
  } else {
8239
    /* default */
8240
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8241
0
    ZEND_VM_CONTINUE();
8242
0
  }
8243
0
}
8244
8245
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8246
0
{
8247
0
  USE_OPLINE
8248
0
  zval *op, *jump_zv;
8249
0
  HashTable *jumptable;
8250
8251
0
  op = RT_CONSTANT(opline, opline->op1);
8252
8253
0
  if (Z_TYPE_P(op) != IS_STRING) {
8254
0
    if (IS_CONST == IS_CONST) {
8255
      /* Wrong type, fall back to ZEND_CASE chain */
8256
0
      ZEND_VM_NEXT_OPCODE();
8257
0
    } else {
8258
0
      ZVAL_DEREF(op);
8259
0
      if (Z_TYPE_P(op) != IS_STRING) {
8260
        /* Wrong type, fall back to ZEND_CASE chain */
8261
0
        ZEND_VM_NEXT_OPCODE();
8262
0
      }
8263
0
    }
8264
0
  }
8265
8266
0
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8267
0
  jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
8268
0
  if (jump_zv != NULL) {
8269
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8270
0
    ZEND_VM_CONTINUE();
8271
0
  } else {
8272
    /* default */
8273
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8274
0
    ZEND_VM_CONTINUE();
8275
0
  }
8276
0
}
8277
8278
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8279
0
{
8280
0
  USE_OPLINE
8281
0
  zval *op, *jump_zv;
8282
0
  HashTable *jumptable;
8283
8284
0
  op = RT_CONSTANT(opline, opline->op1);
8285
0
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8286
8287
0
match_try_again:
8288
0
  if (Z_TYPE_P(op) == IS_LONG) {
8289
0
    jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
8290
0
  } else if (Z_TYPE_P(op) == IS_STRING) {
8291
0
    jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
8292
0
  } else if (Z_TYPE_P(op) == IS_REFERENCE) {
8293
0
    op = Z_REFVAL_P(op);
8294
0
    goto match_try_again;
8295
0
  } else {
8296
0
    if (UNEXPECTED((IS_CONST & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
8297
0
      SAVE_OPLINE();
8298
0
      op = ZVAL_UNDEFINED_OP1();
8299
0
      if (UNEXPECTED(EG(exception))) {
8300
0
        HANDLE_EXCEPTION();
8301
0
      }
8302
0
      goto match_try_again;
8303
0
    }
8304
8305
0
    goto default_branch;
8306
0
  }
8307
8308
0
  if (jump_zv != NULL) {
8309
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8310
0
    ZEND_VM_CONTINUE();
8311
0
  } else {
8312
0
default_branch:
8313
    /* default */
8314
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8315
0
    ZEND_VM_CONTINUE();
8316
0
  }
8317
0
}
8318
8319
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8320
0
{
8321
0
  USE_OPLINE
8322
0
  zval *op1;
8323
0
  HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8324
0
  zval *result;
8325
8326
0
  op1 = RT_CONSTANT(opline, opline->op1);
8327
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8328
0
    result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CONST == IS_CONST);
8329
0
    if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8330
0
      zval_ptr_dtor_str(op1);
8331
0
    }
8332
0
    ZEND_VM_SMART_BRANCH(result, 0);
8333
0
  }
8334
8335
0
  if (opline->extended_value) {
8336
0
    if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8337
0
      result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8338
0
      ZEND_VM_SMART_BRANCH(result, 0);
8339
0
    }
8340
0
    SAVE_OPLINE();
8341
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8342
0
      op1 = Z_REFVAL_P(op1);
8343
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8344
0
        result = zend_hash_find(ht, Z_STR_P(op1));
8345
8346
0
        ZEND_VM_SMART_BRANCH(result, 0);
8347
0
      } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8348
0
        result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8349
8350
0
        ZEND_VM_SMART_BRANCH(result, 0);
8351
0
      }
8352
0
    } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8353
0
      ZVAL_UNDEFINED_OP1();
8354
0
    }
8355
0
  } else if (Z_TYPE_P(op1) <= IS_FALSE) {
8356
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8357
0
      SAVE_OPLINE();
8358
0
      ZVAL_UNDEFINED_OP1();
8359
0
      if (UNEXPECTED(EG(exception) != NULL)) {
8360
0
        HANDLE_EXCEPTION();
8361
0
      }
8362
0
    }
8363
0
    result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
8364
0
    ZEND_VM_SMART_BRANCH(result, 0);
8365
0
  } else {
8366
0
    zend_string *key;
8367
0
    zval key_tmp;
8368
8369
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8370
0
      op1 = Z_REFVAL_P(op1);
8371
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8372
0
        result = zend_hash_find(ht, Z_STR_P(op1));
8373
8374
0
        ZEND_VM_SMART_BRANCH(result, 0);
8375
0
      }
8376
0
    }
8377
8378
0
    SAVE_OPLINE();
8379
0
    ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
8380
0
      ZVAL_STR(&key_tmp, key);
8381
0
      if (zend_compare(op1, &key_tmp) == 0) {
8382
8383
0
        ZEND_VM_SMART_BRANCH(1, 1);
8384
0
      }
8385
0
    } ZEND_HASH_FOREACH_END();
8386
0
  }
8387
8388
0
  ZEND_VM_SMART_BRANCH(0, 1);
8389
0
}
8390
8391
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8392
3.48k
{
8393
3.48k
  USE_OPLINE
8394
3.48k
  zval *op1, *op2, *result;
8395
3.48k
  double d1, d2;
8396
8397
3.48k
  op1 = RT_CONSTANT(opline, opline->op1);
8398
3.48k
  op2 = EX_VAR(opline->op2.var);
8399
3.48k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8400
    /* pass */
8401
3.48k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8402
2.36k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8403
550
      result = EX_VAR(opline->result.var);
8404
550
      fast_long_add_function(result, op1, op2);
8405
550
      ZEND_VM_NEXT_OPCODE();
8406
1.81k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8407
101
      d1 = (double)Z_LVAL_P(op1);
8408
101
      d2 = Z_DVAL_P(op2);
8409
101
      goto add_double;
8410
101
    }
8411
2.36k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8412
103
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8413
42
      d1 = Z_DVAL_P(op1);
8414
42
      d2 = Z_DVAL_P(op2);
8415
179
add_double:
8416
179
      result = EX_VAR(opline->result.var);
8417
179
      ZVAL_DOUBLE(result, d1 + d2);
8418
179
      ZEND_VM_NEXT_OPCODE();
8419
179
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8420
36
      d1 = Z_DVAL_P(op1);
8421
36
      d2 = (double)Z_LVAL_P(op2);
8422
36
      goto add_double;
8423
36
    }
8424
103
  }
8425
8426
3.48k
  ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8427
3.48k
}
8428
8429
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8430
5.16k
{
8431
5.16k
  USE_OPLINE
8432
5.16k
  zval *op1, *op2, *result;
8433
5.16k
  double d1, d2;
8434
8435
5.16k
  op1 = RT_CONSTANT(opline, opline->op1);
8436
5.16k
  op2 = EX_VAR(opline->op2.var);
8437
5.16k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8438
    /* pass */
8439
5.16k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8440
4.38k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8441
2.13k
      result = EX_VAR(opline->result.var);
8442
2.13k
      fast_long_sub_function(result, op1, op2);
8443
2.13k
      ZEND_VM_NEXT_OPCODE();
8444
2.24k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8445
241
      d1 = (double)Z_LVAL_P(op1);
8446
241
      d2 = Z_DVAL_P(op2);
8447
241
      goto sub_double;
8448
241
    }
8449
4.38k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8450
480
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8451
112
      d1 = Z_DVAL_P(op1);
8452
112
      d2 = Z_DVAL_P(op2);
8453
590
sub_double:
8454
590
      result = EX_VAR(opline->result.var);
8455
590
      ZVAL_DOUBLE(result, d1 - d2);
8456
590
      ZEND_VM_NEXT_OPCODE();
8457
590
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8458
237
      d1 = Z_DVAL_P(op1);
8459
237
      d2 = (double)Z_LVAL_P(op2);
8460
237
      goto sub_double;
8461
237
    }
8462
480
  }
8463
8464
5.16k
  ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8465
5.16k
}
8466
8467
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8468
659
{
8469
659
  USE_OPLINE
8470
659
  zval *op1, *op2, *result;
8471
8472
659
  op1 = RT_CONSTANT(opline, opline->op1);
8473
659
  op2 = EX_VAR(opline->op2.var);
8474
659
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8475
    /* pass */
8476
659
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8477
595
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8478
427
      result = EX_VAR(opline->result.var);
8479
427
      if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
8480
16
        ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8481
411
      } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
8482
        /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
8483
44
        ZVAL_LONG(result, 0);
8484
367
      } else {
8485
367
        ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
8486
367
      }
8487
411
      ZEND_VM_NEXT_OPCODE();
8488
411
    }
8489
595
  }
8490
8491
659
  ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8492
659
}
8493
8494
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8495
1.62k
{
8496
1.62k
  USE_OPLINE
8497
1.62k
  zval *op1, *op2;
8498
8499
1.62k
  op1 = RT_CONSTANT(opline, opline->op1);
8500
1.62k
  op2 = EX_VAR(opline->op2.var);
8501
1.62k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8502
    /* pass */
8503
1.62k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8504
1.62k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8505
1.62k
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8506
    /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
8507
1.55k
    ZVAL_LONG(EX_VAR(opline->result.var),
8508
1.55k
      (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
8509
1.55k
    ZEND_VM_NEXT_OPCODE();
8510
1.55k
  }
8511
8512
1.62k
  ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8513
1.62k
}
8514
8515
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8516
884
{
8517
884
  USE_OPLINE
8518
884
  zval *op1, *op2;
8519
8520
884
  op1 = RT_CONSTANT(opline, opline->op1);
8521
884
  op2 = EX_VAR(opline->op2.var);
8522
884
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8523
    /* pass */
8524
884
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8525
884
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8526
884
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8527
665
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
8528
665
    ZEND_VM_NEXT_OPCODE();
8529
665
  }
8530
8531
884
  ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8532
884
}
8533
8534
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8535
1.97k
{
8536
1.97k
  USE_OPLINE
8537
1.97k
  zval *op1, *op2;
8538
1.97k
  double d1, d2;
8539
8540
1.97k
  op1 = RT_CONSTANT(opline, opline->op1);
8541
1.97k
  op2 = EX_VAR(opline->op2.var);
8542
1.97k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8543
    /* pass */
8544
1.97k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8545
1.08k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8546
1.00k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8547
190
is_smaller_true:
8548
190
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
8549
938
      } else {
8550
974
is_smaller_false:
8551
974
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
8552
974
      }
8553
1.00k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8554
30
      d1 = (double)Z_LVAL_P(op1);
8555
30
      d2 = Z_DVAL_P(op2);
8556
30
      goto is_smaller_double;
8557
30
    }
8558
1.08k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8559
436
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8560
12
      d1 = Z_DVAL_P(op1);
8561
12
      d2 = Z_DVAL_P(op2);
8562
163
is_smaller_double:
8563
163
      if (d1 < d2) {
8564
127
        goto is_smaller_true;
8565
127
      } else {
8566
36
        goto is_smaller_false;
8567
36
      }
8568
424
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8569
121
      d1 = Z_DVAL_P(op1);
8570
121
      d2 = (double)Z_LVAL_P(op2);
8571
121
      goto is_smaller_double;
8572
121
    }
8573
436
  }
8574
1.97k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8575
1.97k
}
8576
8577
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8578
2.04k
{
8579
2.04k
  USE_OPLINE
8580
2.04k
  zval *op1, *op2;
8581
2.04k
  double d1, d2;
8582
8583
2.04k
  op1 = RT_CONSTANT(opline, opline->op1);
8584
2.04k
  op2 = EX_VAR(opline->op2.var);
8585
2.04k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8586
    /* pass */
8587
2.04k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8588
1.93k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8589
1.31k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8590
416
is_smaller_true:
8591
416
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8592
907
      } else {
8593
1.07k
is_smaller_false:
8594
1.07k
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8595
1.07k
      }
8596
1.31k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8597
89
      d1 = (double)Z_LVAL_P(op1);
8598
89
      d2 = Z_DVAL_P(op2);
8599
89
      goto is_smaller_double;
8600
89
    }
8601
1.93k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8602
96
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8603
13
      d1 = Z_DVAL_P(op1);
8604
13
      d2 = Z_DVAL_P(op2);
8605
176
is_smaller_double:
8606
176
      if (d1 < d2) {
8607
13
        goto is_smaller_true;
8608
163
      } else {
8609
163
        goto is_smaller_false;
8610
163
      }
8611
176
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8612
74
      d1 = Z_DVAL_P(op1);
8613
74
      d2 = (double)Z_LVAL_P(op2);
8614
74
      goto is_smaller_double;
8615
74
    }
8616
96
  }
8617
2.04k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8618
2.04k
}
8619
8620
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8621
897
{
8622
897
  USE_OPLINE
8623
897
  zval *op1, *op2;
8624
897
  double d1, d2;
8625
8626
897
  op1 = RT_CONSTANT(opline, opline->op1);
8627
897
  op2 = EX_VAR(opline->op2.var);
8628
897
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8629
    /* pass */
8630
897
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8631
615
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8632
409
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8633
123
is_smaller_true:
8634
123
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8635
286
      } else {
8636
286
is_smaller_false:
8637
286
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8638
286
      }
8639
409
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8640
0
      d1 = (double)Z_LVAL_P(op1);
8641
0
      d2 = Z_DVAL_P(op2);
8642
0
      goto is_smaller_double;
8643
0
    }
8644
615
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8645
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8646
0
      d1 = Z_DVAL_P(op1);
8647
0
      d2 = Z_DVAL_P(op2);
8648
0
is_smaller_double:
8649
0
      if (d1 < d2) {
8650
0
        goto is_smaller_true;
8651
0
      } else {
8652
0
        goto is_smaller_false;
8653
0
      }
8654
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8655
0
      d1 = Z_DVAL_P(op1);
8656
0
      d2 = (double)Z_LVAL_P(op2);
8657
0
      goto is_smaller_double;
8658
0
    }
8659
0
  }
8660
897
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8661
897
}
8662
8663
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8664
535
{
8665
535
  USE_OPLINE
8666
535
  zval *op1, *op2;
8667
535
  double d1, d2;
8668
8669
535
  op1 = RT_CONSTANT(opline, opline->op1);
8670
535
  op2 = EX_VAR(opline->op2.var);
8671
535
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8672
    /* pass */
8673
535
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8674
503
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8675
299
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8676
72
is_smaller_or_equal_true:
8677
72
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
8678
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
8679
0
        ZEND_VM_NEXT_OPCODE();
8680
227
      } else {
8681
227
is_smaller_or_equal_false:
8682
227
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
8683
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
8684
0
        ZEND_VM_NEXT_OPCODE();
8685
0
      }
8686
299
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8687
0
      d1 = (double)Z_LVAL_P(op1);
8688
0
      d2 = Z_DVAL_P(op2);
8689
0
      goto is_smaller_or_equal_double;
8690
0
    }
8691
503
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8692
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8693
0
      d1 = Z_DVAL_P(op1);
8694
0
      d2 = Z_DVAL_P(op2);
8695
0
is_smaller_or_equal_double:
8696
0
      if (d1 <= d2) {
8697
0
        goto is_smaller_or_equal_true;
8698
0
      } else {
8699
0
        goto is_smaller_or_equal_false;
8700
0
      }
8701
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8702
0
      d1 = Z_DVAL_P(op1);
8703
0
      d2 = (double)Z_LVAL_P(op2);
8704
0
      goto is_smaller_or_equal_double;
8705
0
    }
8706
0
  }
8707
535
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8708
535
}
8709
8710
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8711
2.26k
{
8712
2.26k
  USE_OPLINE
8713
2.26k
  zval *op1, *op2;
8714
2.26k
  double d1, d2;
8715
8716
2.26k
  op1 = RT_CONSTANT(opline, opline->op1);
8717
2.26k
  op2 = EX_VAR(opline->op2.var);
8718
2.26k
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8719
    /* pass */
8720
2.26k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8721
2.25k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8722
1.79k
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8723
1.09k
is_smaller_or_equal_true:
8724
1.09k
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8725
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
8726
0
        ZEND_VM_NEXT_OPCODE();
8727
696
      } else {
8728
696
is_smaller_or_equal_false:
8729
696
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8730
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
8731
0
        ZEND_VM_NEXT_OPCODE();
8732
0
      }
8733
1.79k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8734
0
      d1 = (double)Z_LVAL_P(op1);
8735
0
      d2 = Z_DVAL_P(op2);
8736
0
      goto is_smaller_or_equal_double;
8737
0
    }
8738
2.25k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8739
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8740
0
      d1 = Z_DVAL_P(op1);
8741
0
      d2 = Z_DVAL_P(op2);
8742
0
is_smaller_or_equal_double:
8743
0
      if (d1 <= d2) {
8744
0
        goto is_smaller_or_equal_true;
8745
0
      } else {
8746
0
        goto is_smaller_or_equal_false;
8747
0
      }
8748
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8749
0
      d1 = Z_DVAL_P(op1);
8750
0
      d2 = (double)Z_LVAL_P(op2);
8751
0
      goto is_smaller_or_equal_double;
8752
0
    }
8753
0
  }
8754
2.26k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8755
2.26k
}
8756
8757
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8758
940
{
8759
940
  USE_OPLINE
8760
940
  zval *op1, *op2;
8761
940
  double d1, d2;
8762
8763
940
  op1 = RT_CONSTANT(opline, opline->op1);
8764
940
  op2 = EX_VAR(opline->op2.var);
8765
940
  if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8766
    /* pass */
8767
940
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8768
720
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8769
197
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8770
191
is_smaller_or_equal_true:
8771
191
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8772
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
8773
0
        ZEND_VM_NEXT_OPCODE();
8774
6
      } else {
8775
6
is_smaller_or_equal_false:
8776
6
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8777
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
8778
0
        ZEND_VM_NEXT_OPCODE();
8779
0
      }
8780
523
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8781
0
      d1 = (double)Z_LVAL_P(op1);
8782
0
      d2 = Z_DVAL_P(op2);
8783
0
      goto is_smaller_or_equal_double;
8784
0
    }
8785
720
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8786
0
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8787
0
      d1 = Z_DVAL_P(op1);
8788
0
      d2 = Z_DVAL_P(op2);
8789
0
is_smaller_or_equal_double:
8790
0
      if (d1 <= d2) {
8791
0
        goto is_smaller_or_equal_true;
8792
0
      } else {
8793
0
        goto is_smaller_or_equal_false;
8794
0
      }
8795
0
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8796
0
      d1 = Z_DVAL_P(op1);
8797
0
      d2 = (double)Z_LVAL_P(op2);
8798
0
      goto is_smaller_or_equal_double;
8799
0
    }
8800
0
  }
8801
940
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
8802
940
}
8803
8804
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8805
237
{
8806
237
  zend_class_entry *ce, *scope;
8807
237
  zend_class_constant *c;
8808
237
  zval *value, *zv, *constant_zv;
8809
237
  zend_string *constant_name;
8810
237
  USE_OPLINE
8811
8812
237
  SAVE_OPLINE();
8813
8814
237
  do {
8815
237
    if (IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8816
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
8817
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
8818
0
        break;
8819
0
      }
8820
0
    }
8821
237
    if (IS_CONST == IS_CONST) {
8822
237
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
8823
10
        ce = CACHED_PTR(opline->extended_value);
8824
227
      } else {
8825
227
        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);
8826
227
        if (UNEXPECTED(ce == NULL)) {
8827
21
          ZVAL_UNDEF(EX_VAR(opline->result.var));
8828
21
          FREE_OP(opline->op2_type, opline->op2.var);
8829
21
          HANDLE_EXCEPTION();
8830
21
        }
8831
206
        CACHE_PTR(opline->extended_value, ce);
8832
206
      }
8833
237
    } else if (IS_CONST == IS_UNUSED) {
8834
0
      ce = zend_fetch_class(NULL, opline->op1.num);
8835
0
      if (UNEXPECTED(ce == NULL)) {
8836
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
8837
0
        FREE_OP(opline->op2_type, opline->op2.var);
8838
0
        HANDLE_EXCEPTION();
8839
0
      }
8840
0
    } else {
8841
0
      ce = Z_CE_P(EX_VAR(opline->op1.var));
8842
0
    }
8843
216
    if (IS_CONST != IS_CONST
8844
216
      && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8845
216
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
8846
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
8847
0
      break;
8848
0
    }
8849
8850
216
    constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
8851
216
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
8852
65
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
8853
65
      ZVAL_UNDEF(EX_VAR(opline->result.var));
8854
65
      FREE_OP(opline->op2_type, opline->op2.var);
8855
65
      HANDLE_EXCEPTION();
8856
65
    }
8857
151
    constant_name = Z_STR_P(constant_zv);
8858
    /* Magic 'class' for constant OP2 is caught at compile-time */
8859
151
    if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
8860
23
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
8861
23
      FREE_OP(opline->op2_type, opline->op2.var);
8862
23
      ZEND_VM_NEXT_OPCODE();
8863
23
    }
8864
128
    zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8865
128
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
8866
128
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
8867
8868
128
    if (EXPECTED(zv != NULL)) {
8869
119
      c = Z_PTR_P(zv);
8870
119
      scope = EX(func)->op_array.scope;
8871
119
      if (!zend_verify_const_access(c, scope)) {
8872
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));
8873
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
8874
0
        FREE_OP(opline->op2_type, opline->op2.var);
8875
0
        HANDLE_EXCEPTION();
8876
0
      }
8877
8878
119
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
8879
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8880
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
8881
0
        FREE_OP(opline->op2_type, opline->op2.var);
8882
0
        HANDLE_EXCEPTION();
8883
0
      }
8884
8885
119
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
8886
119
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
8887
0
        if (c->ce->type == ZEND_USER_CLASS) {
8888
          /* Recursion protection only applied to user constants, GH-18463 */
8889
0
          CONST_PROTECT_RECURSION(c);
8890
0
        }
8891
0
        zend_deprecated_class_constant(c, constant_name);
8892
0
        if (c->ce->type == ZEND_USER_CLASS) {
8893
0
          CONST_UNPROTECT_RECURSION(c);
8894
0
        }
8895
8896
0
        if (EG(exception)) {
8897
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
8898
0
          FREE_OP(opline->op2_type, opline->op2.var);
8899
0
          HANDLE_EXCEPTION();
8900
0
        }
8901
0
      }
8902
8903
119
      value = &c->value;
8904
      // Enums require loading of all class constants to build the backed enum table
8905
119
      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)) {
8906
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
8907
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
8908
0
          FREE_OP(opline->op2_type, opline->op2.var);
8909
0
          HANDLE_EXCEPTION();
8910
0
        }
8911
0
      }
8912
119
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
8913
0
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
8914
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
8915
0
          FREE_OP(opline->op2_type, opline->op2.var);
8916
0
          HANDLE_EXCEPTION();
8917
0
        }
8918
0
      }
8919
119
      if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
8920
0
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
8921
0
      }
8922
119
    } else {
8923
9
      zend_throw_error(NULL, "Undefined constant %s::%s",
8924
9
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8925
9
      ZVAL_UNDEF(EX_VAR(opline->result.var));
8926
9
      FREE_OP(opline->op2_type, opline->op2.var);
8927
9
      HANDLE_EXCEPTION();
8928
9
    }
8929
128
  } while (0);
8930
8931
119
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
8932
8933
119
  FREE_OP(opline->op2_type, opline->op2.var);
8934
119
  ZEND_VM_NEXT_OPCODE();
8935
119
}
8936
8937
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8938
251
{
8939
251
  USE_OPLINE
8940
251
  zval *op1, *op2, *result;
8941
8942
251
  op1 = RT_CONSTANT(opline, opline->op1);
8943
251
  op2 = EX_VAR(opline->op2.var);
8944
251
  result = EX_VAR(opline->result.var);
8945
251
  ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
8946
251
  ZEND_VM_NEXT_OPCODE();
8947
251
}
8948
8949
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8950
330
{
8951
330
  USE_OPLINE
8952
330
  zval *op1, *op2, *result;
8953
8954
330
  op1 = RT_CONSTANT(opline, opline->op1);
8955
330
  op2 = EX_VAR(opline->op2.var);
8956
330
  result = EX_VAR(opline->result.var);
8957
330
  fast_long_sub_function(result, op1, op2);
8958
330
  ZEND_VM_NEXT_OPCODE();
8959
330
}
8960
8961
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8962
0
{
8963
0
  USE_OPLINE
8964
0
  zval *op1, *op2, *result;
8965
8966
0
  op1 = RT_CONSTANT(opline, opline->op1);
8967
0
  op2 = EX_VAR(opline->op2.var);
8968
0
  result = EX_VAR(opline->result.var);
8969
0
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
8970
0
  ZEND_VM_NEXT_OPCODE();
8971
0
}
8972
8973
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8974
28
{
8975
28
  USE_OPLINE
8976
28
  zval *op1, *op2;
8977
28
  bool result;
8978
8979
28
  op1 = RT_CONSTANT(opline, opline->op1);
8980
28
  op2 = EX_VAR(opline->op2.var);
8981
28
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8982
28
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
8983
28
}
8984
8985
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8986
311
{
8987
311
  USE_OPLINE
8988
311
  zval *op1, *op2;
8989
311
  bool result;
8990
8991
311
  op1 = RT_CONSTANT(opline, opline->op1);
8992
311
  op2 = EX_VAR(opline->op2.var);
8993
311
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8994
311
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8995
311
}
8996
8997
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8998
17
{
8999
17
  USE_OPLINE
9000
17
  zval *op1, *op2;
9001
17
  bool result;
9002
9003
17
  op1 = RT_CONSTANT(opline, opline->op1);
9004
17
  op2 = EX_VAR(opline->op2.var);
9005
17
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
9006
17
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9007
17
}
9008
9009
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9010
71
{
9011
71
  USE_OPLINE
9012
71
  zval *op1, *op2;
9013
71
  bool result;
9014
9015
71
  op1 = RT_CONSTANT(opline, opline->op1);
9016
71
  op2 = EX_VAR(opline->op2.var);
9017
71
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
9018
71
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
9019
71
}
9020
9021
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9022
124
{
9023
124
  USE_OPLINE
9024
124
  zval *op1, *op2;
9025
124
  bool result;
9026
9027
124
  op1 = RT_CONSTANT(opline, opline->op1);
9028
124
  op2 = EX_VAR(opline->op2.var);
9029
124
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
9030
124
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
9031
124
}
9032
9033
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9034
0
{
9035
0
  USE_OPLINE
9036
0
  zval *op1, *op2;
9037
0
  bool result;
9038
9039
0
  op1 = RT_CONSTANT(opline, opline->op1);
9040
0
  op2 = EX_VAR(opline->op2.var);
9041
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
9042
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9043
0
}
9044
9045
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9046
63
{
9047
63
  USE_OPLINE
9048
63
  zval *op1, *op2;
9049
63
  bool result;
9050
9051
63
  op1 = RT_CONSTANT(opline, opline->op1);
9052
63
  op2 = EX_VAR(opline->op2.var);
9053
63
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
9054
63
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
9055
63
}
9056
9057
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)
9058
802
{
9059
802
  USE_OPLINE
9060
802
  zval *op1, *op2;
9061
802
  bool result;
9062
9063
802
  op1 = RT_CONSTANT(opline, opline->op1);
9064
802
  op2 = EX_VAR(opline->op2.var);
9065
802
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
9066
802
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
9067
802
}
9068
9069
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)
9070
0
{
9071
0
  USE_OPLINE
9072
0
  zval *op1, *op2;
9073
0
  bool result;
9074
9075
0
  op1 = RT_CONSTANT(opline, opline->op1);
9076
0
  op2 = EX_VAR(opline->op2.var);
9077
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
9078
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9079
0
}
9080
9081
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9082
0
{
9083
0
  USE_OPLINE
9084
0
  zval *op1, *op2;
9085
0
  bool result;
9086
9087
0
  op1 = RT_CONSTANT(opline, opline->op1);
9088
0
  op2 = EX_VAR(opline->op2.var);
9089
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
9090
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
9091
0
}
9092
9093
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)
9094
0
{
9095
0
  USE_OPLINE
9096
0
  zval *op1, *op2;
9097
0
  bool result;
9098
9099
0
  op1 = RT_CONSTANT(opline, opline->op1);
9100
0
  op2 = EX_VAR(opline->op2.var);
9101
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
9102
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
9103
0
}
9104
9105
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)
9106
0
{
9107
0
  USE_OPLINE
9108
0
  zval *op1, *op2;
9109
0
  bool result;
9110
9111
0
  op1 = RT_CONSTANT(opline, opline->op1);
9112
0
  op2 = EX_VAR(opline->op2.var);
9113
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
9114
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9115
0
}
9116
9117
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9118
162
{
9119
162
  USE_OPLINE
9120
162
  zval *container, *dim, *value;
9121
162
  zend_long offset;
9122
162
  HashTable *ht;
9123
9124
162
  container = RT_CONSTANT(opline, opline->op1);
9125
162
  dim = EX_VAR(opline->op2.var);
9126
162
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9127
42
fetch_dim_r_index_array:
9128
42
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
9129
42
      offset = Z_LVAL_P(dim);
9130
42
    } else {
9131
0
      SAVE_OPLINE();
9132
0
      zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
9133
9134
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9135
0
    }
9136
42
    ht = Z_ARRVAL_P(container);
9137
42
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
9138
21
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
9139
21
    if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9140
0
      SAVE_OPLINE();
9141
9142
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9143
21
    } else {
9144
21
      ZEND_VM_NEXT_OPCODE();
9145
21
    }
9146
120
  } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
9147
0
    container = Z_REFVAL_P(container);
9148
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9149
0
      goto fetch_dim_r_index_array;
9150
0
    } else {
9151
0
      goto fetch_dim_r_index_slow;
9152
0
    }
9153
120
  } else {
9154
120
fetch_dim_r_index_slow:
9155
120
    SAVE_OPLINE();
9156
120
    if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
9157
0
      dim++;
9158
0
    }
9159
120
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
9160
9161
120
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9162
120
  }
9163
9164
21
fetch_dim_r_index_undef:
9165
21
  ZVAL_NULL(EX_VAR(opline->result.var));
9166
21
  SAVE_OPLINE();
9167
21
  zend_undefined_offset(offset);
9168
9169
21
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9170
21
}
9171
9172
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9173
145
{
9174
145
  USE_OPLINE
9175
145
  zval *op1, *op2;
9176
9177
145
  SAVE_OPLINE();
9178
145
  op1 = RT_CONSTANT(opline, opline->op1);
9179
145
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9180
145
  div_function(EX_VAR(opline->result.var), op1, op2);
9181
9182
145
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9183
145
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9184
145
}
9185
9186
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9187
19
{
9188
19
  USE_OPLINE
9189
19
  zval *op1, *op2;
9190
9191
19
  SAVE_OPLINE();
9192
19
  op1 = RT_CONSTANT(opline, opline->op1);
9193
19
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9194
19
  pow_function(EX_VAR(opline->result.var), op1, op2);
9195
9196
19
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9197
19
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9198
19
}
9199
9200
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9201
2.00k
{
9202
2.00k
  USE_OPLINE
9203
2.00k
  zval *op1, *op2;
9204
9205
2.00k
  op1 = RT_CONSTANT(opline, opline->op1);
9206
2.00k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9207
9208
2.00k
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9209
2.00k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9210
861
    zend_string *op1_str = Z_STR_P(op1);
9211
861
    zend_string *op2_str = Z_STR_P(op2);
9212
861
    zend_string *str;
9213
861
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9214
9215
861
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9216
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9217
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9218
0
      } else {
9219
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9220
0
      }
9221
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9222
0
        zend_string_release_ex(op1_str, 0);
9223
0
      }
9224
861
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9225
0
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9226
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9227
0
      } else {
9228
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9229
0
      }
9230
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9231
0
        zend_string_release_ex(op2_str, 0);
9232
0
      }
9233
861
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9234
861
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9235
0
      size_t len = ZSTR_LEN(op1_str);
9236
9237
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
9238
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
9239
0
      }
9240
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9241
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9242
0
      GC_ADD_FLAGS(str, flags);
9243
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9244
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9245
0
        zend_string_release_ex(op2_str, 0);
9246
0
      }
9247
861
    } else {
9248
861
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9249
861
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9250
861
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9251
861
      GC_ADD_FLAGS(str, flags);
9252
861
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9253
861
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9254
0
        zend_string_release_ex(op1_str, 0);
9255
0
      }
9256
861
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9257
861
        zend_string_release_ex(op2_str, 0);
9258
861
      }
9259
861
    }
9260
861
    ZEND_VM_NEXT_OPCODE();
9261
1.14k
  } else {
9262
1.14k
    SAVE_OPLINE();
9263
9264
1.14k
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9265
0
      op1 = ZVAL_UNDEFINED_OP1();
9266
0
    }
9267
1.14k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9268
0
      op2 = ZVAL_UNDEFINED_OP2();
9269
0
    }
9270
1.14k
    concat_function(EX_VAR(opline->result.var), op1, op2);
9271
9272
1.14k
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9273
1.14k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9274
1.14k
  }
9275
2.00k
}
9276
9277
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9278
0
{
9279
0
  USE_OPLINE
9280
0
  zval *op1, *op2;
9281
9282
0
  SAVE_OPLINE();
9283
0
  op1 = RT_CONSTANT(opline, opline->op1);
9284
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9285
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
9286
9287
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9288
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9289
0
}
9290
9291
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9292
27
{
9293
27
  USE_OPLINE
9294
27
  zval *container, *dim, *value;
9295
9296
27
  SAVE_OPLINE();
9297
27
  container = RT_CONSTANT(opline, opline->op1);
9298
27
  dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9299
27
  if (IS_CONST != IS_CONST) {
9300
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9301
0
fetch_dim_r_array:
9302
0
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
9303
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
9304
0
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
9305
0
      container = Z_REFVAL_P(container);
9306
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9307
0
        goto fetch_dim_r_array;
9308
0
      } else {
9309
0
        goto fetch_dim_r_slow;
9310
0
      }
9311
0
    } else {
9312
0
fetch_dim_r_slow:
9313
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
9314
0
        dim++;
9315
0
      }
9316
0
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
9317
0
    }
9318
27
  } else {
9319
27
    zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
9320
27
  }
9321
27
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9322
9323
27
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9324
27
}
9325
9326
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9327
0
{
9328
0
  USE_OPLINE
9329
0
  zval *container;
9330
9331
0
  SAVE_OPLINE();
9332
0
  container = RT_CONSTANT(opline, opline->op1);
9333
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);
9334
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9335
9336
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9337
0
}
9338
9339
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9340
0
{
9341
#if 0
9342
  USE_OPLINE
9343
#endif
9344
9345
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9346
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9347
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9348
0
    }
9349
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9350
0
  } else {
9351
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
9352
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9353
0
    }
9354
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9355
0
  }
9356
0
}
9357
9358
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9359
0
{
9360
0
  USE_OPLINE
9361
0
  zval *container;
9362
0
  void **cache_slot = NULL;
9363
9364
0
  SAVE_OPLINE();
9365
0
  container = RT_CONSTANT(opline, opline->op1);
9366
9367
0
  if (IS_CONST == IS_CONST ||
9368
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9369
0
    do {
9370
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9371
0
        container = Z_REFVAL_P(container);
9372
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9373
0
          break;
9374
0
        }
9375
0
      }
9376
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
9377
0
        ZVAL_UNDEFINED_OP1();
9378
0
      }
9379
0
      zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9380
0
      ZVAL_NULL(EX_VAR(opline->result.var));
9381
0
      goto fetch_obj_r_finish;
9382
0
    } while (0);
9383
0
  }
9384
9385
  /* here we are sure we are dealing with an object */
9386
0
  do {
9387
0
    zend_object *zobj = Z_OBJ_P(container);
9388
0
    zend_string *name, *tmp_name;
9389
0
    zval *retval;
9390
9391
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9392
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
9393
9394
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9395
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9396
9397
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9398
0
fetch_obj_r_simple:
9399
0
          retval = OBJ_PROP(zobj, prop_offset);
9400
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
9401
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9402
0
              goto fetch_obj_r_copy;
9403
0
            } else {
9404
0
fetch_obj_r_fast_copy:
9405
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9406
0
              ZEND_VM_NEXT_OPCODE();
9407
0
            }
9408
0
          }
9409
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
9410
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
9411
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
9412
0
            prop_offset = prop_info->offset;
9413
0
            goto fetch_obj_r_simple;
9414
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
9415
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
9416
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
9417
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
9418
9419
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9420
0
            if (IS_CONST & IS_CV) {
9421
0
              GC_ADDREF(zobj);
9422
0
            }
9423
0
            if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
9424
0
              call_info |= ZEND_CALL_RELEASE_THIS;
9425
0
            }
9426
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
9427
0
            call->prev_execute_data = execute_data;
9428
0
            call->call = NULL;
9429
0
            call->return_value = EX_VAR(opline->result.var);
9430
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
9431
9432
0
            execute_data = call;
9433
0
            EG(current_execute_data) = execute_data;
9434
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
9435
9436
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
9437
            opline = hook->op_array.opcodes;
9438
#else
9439
0
            EX(opline) = hook->op_array.opcodes;
9440
0
#endif
9441
0
            LOAD_OPLINE_EX();
9442
9443
9444
0
            ZEND_VM_ENTER_EX();
9445
0
          }
9446
          /* Fall through to read_property for hooks. */
9447
0
        } else if (EXPECTED(zobj->properties != NULL)) {
9448
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
9449
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9450
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9451
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9452
9453
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9454
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9455
9456
0
              if (EXPECTED(p->key == name) ||
9457
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
9458
0
                   EXPECTED(p->key != NULL) &&
9459
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
9460
0
                retval = &p->val;
9461
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9462
0
                  goto fetch_obj_r_copy;
9463
0
                } else {
9464
0
                  goto fetch_obj_r_fast_copy;
9465
0
                }
9466
0
              }
9467
0
            }
9468
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9469
0
          }
9470
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
9471
0
          if (EXPECTED(retval)) {
9472
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9473
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9474
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9475
0
              goto fetch_obj_r_copy;
9476
0
            } else {
9477
0
              goto fetch_obj_r_fast_copy;
9478
0
            }
9479
0
          }
9480
0
        }
9481
0
      }
9482
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9483
0
    } else {
9484
0
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9485
0
      if (UNEXPECTED(!name)) {
9486
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
9487
0
        break;
9488
0
      }
9489
0
    }
9490
9491
0
#if ZEND_DEBUG
9492
    /* For non-standard object handlers, verify a declared property type in debug builds.
9493
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
9494
0
    zend_property_info *prop_info = NULL;
9495
0
    if (zobj->handlers->read_property != zend_std_read_property) {
9496
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
9497
0
    }
9498
0
#endif
9499
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
9500
0
#if ZEND_DEBUG
9501
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
9502
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
9503
0
      ZVAL_OPT_DEREF(retval);
9504
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
9505
0
    }
9506
0
#endif
9507
9508
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9509
0
      zend_tmp_string_release(tmp_name);
9510
0
    }
9511
9512
0
    if (retval != EX_VAR(opline->result.var)) {
9513
0
fetch_obj_r_copy:
9514
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9515
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9516
0
      zend_unwrap_reference(retval);
9517
0
    }
9518
0
  } while (0);
9519
9520
0
fetch_obj_r_finish:
9521
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9522
9523
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9524
0
}
9525
9526
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9527
0
{
9528
0
  USE_OPLINE
9529
0
  zval *container;
9530
0
  void **cache_slot = NULL;
9531
9532
0
  SAVE_OPLINE();
9533
0
  container = RT_CONSTANT(opline, opline->op1);
9534
9535
0
  if (IS_CONST == IS_CONST ||
9536
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9537
0
    do {
9538
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9539
0
        container = Z_REFVAL_P(container);
9540
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9541
0
          break;
9542
0
        }
9543
0
      }
9544
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
9545
0
        ZVAL_UNDEFINED_OP2();
9546
0
      }
9547
0
      ZVAL_NULL(EX_VAR(opline->result.var));
9548
0
      goto fetch_obj_is_finish;
9549
0
    } while (0);
9550
0
  }
9551
9552
  /* here we are sure we are dealing with an object */
9553
0
  do {
9554
0
    zend_object *zobj = Z_OBJ_P(container);
9555
0
    zend_string *name, *tmp_name;
9556
0
    zval *retval;
9557
9558
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9559
0
      cache_slot = CACHE_ADDR(opline->extended_value);
9560
9561
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9562
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9563
9564
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9565
0
fetch_obj_is_simple:
9566
0
          retval = OBJ_PROP(zobj, prop_offset);
9567
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
9568
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9569
0
              goto fetch_obj_is_copy;
9570
0
            } else {
9571
0
fetch_obj_is_fast_copy:
9572
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9573
0
              ZEND_VM_NEXT_OPCODE();
9574
0
            }
9575
0
          }
9576
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
9577
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
9578
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
9579
0
            prop_offset = prop_info->offset;
9580
0
            goto fetch_obj_is_simple;
9581
0
          }
9582
          /* Fall through to read_property for hooks. */
9583
0
        } else if (EXPECTED(zobj->properties != NULL)) {
9584
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
9585
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9586
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9587
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9588
9589
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9590
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9591
9592
0
              if (EXPECTED(p->key == name) ||
9593
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
9594
0
                   EXPECTED(p->key != NULL) &&
9595
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
9596
0
                retval = &p->val;
9597
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9598
0
                  goto fetch_obj_is_copy;
9599
0
                } else {
9600
0
                  goto fetch_obj_is_fast_copy;
9601
0
                }
9602
0
              }
9603
0
            }
9604
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9605
0
          }
9606
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
9607
0
          if (EXPECTED(retval)) {
9608
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9609
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9610
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9611
0
              goto fetch_obj_is_copy;
9612
0
            } else {
9613
0
              goto fetch_obj_is_fast_copy;
9614
0
            }
9615
0
          }
9616
0
        }
9617
0
      }
9618
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9619
0
    } else {
9620
0
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9621
0
      if (UNEXPECTED(!name)) {
9622
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
9623
0
        break;
9624
0
      }
9625
0
    }
9626
9627
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
9628
9629
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9630
0
      zend_tmp_string_release(tmp_name);
9631
0
    }
9632
9633
0
    if (retval != EX_VAR(opline->result.var)) {
9634
0
fetch_obj_is_copy:
9635
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9636
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9637
0
      zend_unwrap_reference(retval);
9638
0
    }
9639
0
  } while (0);
9640
9641
0
fetch_obj_is_finish:
9642
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9643
9644
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9645
0
}
9646
9647
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9648
0
{
9649
#if 0
9650
  USE_OPLINE
9651
#endif
9652
9653
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9654
    /* Behave like FETCH_OBJ_W */
9655
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9656
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9657
0
    }
9658
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9659
0
  } else {
9660
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9661
0
  }
9662
0
}
9663
9664
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9665
0
{
9666
0
  USE_OPLINE
9667
0
  zval *container;
9668
9669
0
  SAVE_OPLINE();
9670
0
  container = RT_CONSTANT(opline, opline->op1);
9671
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);
9672
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9673
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9674
0
}
9675
9676
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9677
175k
{
9678
175k
  USE_OPLINE
9679
175k
  zval *op1, *op2;
9680
175k
  zend_string *op1_str, *op2_str, *str;
9681
9682
9683
175k
  op1 = RT_CONSTANT(opline, opline->op1);
9684
175k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9685
175k
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9686
175k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9687
174k
    zend_string *op1_str = Z_STR_P(op1);
9688
174k
    zend_string *op2_str = Z_STR_P(op2);
9689
174k
    zend_string *str;
9690
174k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9691
9692
174k
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9693
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9694
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9695
0
      } else {
9696
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9697
0
      }
9698
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9699
0
        zend_string_release_ex(op1_str, 0);
9700
0
      }
9701
174k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9702
123
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9703
123
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9704
123
      } else {
9705
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9706
0
      }
9707
123
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9708
123
        zend_string_release_ex(op2_str, 0);
9709
123
      }
9710
174k
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9711
174k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9712
0
      size_t len = ZSTR_LEN(op1_str);
9713
9714
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9715
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9716
0
      GC_ADD_FLAGS(str, flags);
9717
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9718
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9719
0
        zend_string_release_ex(op2_str, 0);
9720
0
      }
9721
174k
    } else {
9722
174k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9723
174k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9724
174k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9725
174k
      GC_ADD_FLAGS(str, flags);
9726
174k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9727
174k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9728
0
        zend_string_release_ex(op1_str, 0);
9729
0
      }
9730
174k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9731
174k
        zend_string_release_ex(op2_str, 0);
9732
174k
      }
9733
174k
    }
9734
174k
    ZEND_VM_NEXT_OPCODE();
9735
174k
  }
9736
9737
175k
  SAVE_OPLINE();
9738
439
  if (IS_CONST == IS_CONST) {
9739
439
    op1_str = Z_STR_P(op1);
9740
439
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
9741
0
    op1_str = zend_string_copy(Z_STR_P(op1));
9742
0
  } else {
9743
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9744
0
      ZVAL_UNDEFINED_OP1();
9745
0
    }
9746
0
    op1_str = zval_get_string_func(op1);
9747
0
  }
9748
439
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9749
0
    op2_str = Z_STR_P(op2);
9750
439
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
9751
0
    op2_str = zend_string_copy(Z_STR_P(op2));
9752
439
  } else {
9753
439
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9754
0
      ZVAL_UNDEFINED_OP2();
9755
0
    }
9756
439
    op2_str = zval_get_string_func(op2);
9757
439
  }
9758
439
  do {
9759
439
    if (IS_CONST != IS_CONST) {
9760
0
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9761
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9762
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
9763
0
            GC_ADDREF(op2_str);
9764
0
          }
9765
0
        }
9766
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9767
0
        zend_string_release_ex(op1_str, 0);
9768
0
        break;
9769
0
      }
9770
0
    }
9771
439
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9772
439
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9773
178
        if (IS_CONST == IS_CONST) {
9774
178
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
9775
0
            GC_ADDREF(op1_str);
9776
0
          }
9777
178
        }
9778
178
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9779
178
        zend_string_release_ex(op2_str, 0);
9780
178
        break;
9781
178
      }
9782
439
    }
9783
261
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9784
261
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9785
261
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9786
9787
261
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
9788
261
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9789
261
    if (IS_CONST != IS_CONST) {
9790
0
      zend_string_release_ex(op1_str, 0);
9791
0
    }
9792
261
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9793
261
      zend_string_release_ex(op2_str, 0);
9794
261
    }
9795
261
  } while (0);
9796
9797
439
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9798
439
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9799
439
}
9800
9801
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9802
0
{
9803
0
  USE_OPLINE
9804
0
  zval *function_name;
9805
0
  zval *object;
9806
0
  zend_function *fbc;
9807
0
  zend_class_entry *called_scope;
9808
0
  zend_object *obj;
9809
0
  zend_execute_data *call;
9810
0
  uint32_t call_info;
9811
9812
0
  SAVE_OPLINE();
9813
9814
0
  object = RT_CONSTANT(opline, opline->op1);
9815
9816
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9817
0
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9818
0
  }
9819
9820
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
9821
0
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9822
0
    do {
9823
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
9824
0
        function_name = Z_REFVAL_P(function_name);
9825
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9826
0
          break;
9827
0
        }
9828
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9829
0
        ZVAL_UNDEFINED_OP2();
9830
0
        if (UNEXPECTED(EG(exception) != NULL)) {
9831
9832
0
          HANDLE_EXCEPTION();
9833
0
        }
9834
0
      }
9835
0
      zend_throw_error(NULL, "Method name must be a string");
9836
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9837
9838
0
      HANDLE_EXCEPTION();
9839
0
    } while (0);
9840
0
  }
9841
9842
0
  if (IS_CONST == IS_UNUSED) {
9843
0
    obj = Z_OBJ_P(object);
9844
0
  } else {
9845
0
    do {
9846
0
      if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9847
0
        obj = Z_OBJ_P(object);
9848
0
      } else {
9849
0
        if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
9850
0
          zend_reference *ref = Z_REF_P(object);
9851
9852
0
          object = &ref->val;
9853
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9854
0
            obj = Z_OBJ_P(object);
9855
0
            if (IS_CONST & IS_VAR) {
9856
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
9857
0
                efree_size(ref, sizeof(zend_reference));
9858
0
              } else {
9859
0
                Z_ADDREF_P(object);
9860
0
              }
9861
0
            }
9862
0
            break;
9863
0
          }
9864
0
        }
9865
0
        if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
9866
0
          object = ZVAL_UNDEFINED_OP1();
9867
0
          if (UNEXPECTED(EG(exception) != NULL)) {
9868
0
            if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9869
0
              zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9870
0
            }
9871
0
            HANDLE_EXCEPTION();
9872
0
          }
9873
0
        }
9874
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9875
0
          function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9876
0
        }
9877
0
        zend_invalid_method_call(object, function_name);
9878
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9879
9880
0
        HANDLE_EXCEPTION();
9881
0
      }
9882
0
    } while (0);
9883
0
  }
9884
9885
0
  called_scope = obj->ce;
9886
9887
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9888
0
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
9889
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9890
0
  } else {
9891
0
    zend_object *orig_obj = obj;
9892
9893
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9894
0
      function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9895
0
    }
9896
9897
    /* First, locate the function. */
9898
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));
9899
0
    if (UNEXPECTED(fbc == NULL)) {
9900
0
      if (EXPECTED(!EG(exception))) {
9901
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
9902
0
      }
9903
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9904
0
      if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
9905
0
        zend_objects_store_del(orig_obj);
9906
0
      }
9907
0
      HANDLE_EXCEPTION();
9908
0
    }
9909
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9910
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9911
0
        EXPECTED(obj == orig_obj)) {
9912
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
9913
0
    }
9914
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
9915
0
      GC_ADDREF(obj); /* For $this pointer */
9916
0
      if (GC_DELREF(orig_obj) == 0) {
9917
0
        zend_objects_store_del(orig_obj);
9918
0
      }
9919
0
    }
9920
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9921
0
      init_func_run_time_cache(&fbc->op_array);
9922
0
    }
9923
0
  }
9924
9925
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9926
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9927
0
  }
9928
9929
0
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9930
0
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
9931
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
9932
0
      zend_objects_store_del(obj);
9933
0
      if (UNEXPECTED(EG(exception))) {
9934
0
        HANDLE_EXCEPTION();
9935
0
      }
9936
0
    }
9937
    /* call static method */
9938
0
    obj = (zend_object*)called_scope;
9939
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
9940
0
  } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
9941
0
    if (IS_CONST == IS_CV) {
9942
0
      GC_ADDREF(obj); /* For $this pointer */
9943
0
    }
9944
    /* CV may be changed indirectly (e.g. when it's a reference) */
9945
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
9946
0
  }
9947
9948
0
  call = zend_vm_stack_push_call_frame(call_info,
9949
0
    fbc, opline->extended_value, obj);
9950
0
  call->prev_execute_data = EX(call);
9951
0
  EX(call) = call;
9952
9953
0
  ZEND_VM_NEXT_OPCODE();
9954
0
}
9955
9956
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9957
38
{
9958
38
  USE_OPLINE
9959
38
  zval *function_name;
9960
38
  zend_class_entry *ce;
9961
38
  uint32_t call_info;
9962
38
  zend_function *fbc;
9963
38
  zend_execute_data *call;
9964
9965
38
  SAVE_OPLINE();
9966
9967
38
  if (IS_CONST == IS_CONST) {
9968
    /* no function found. try a static method in class */
9969
38
    ce = CACHED_PTR(opline->result.num);
9970
38
    if (UNEXPECTED(ce == NULL)) {
9971
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);
9972
15
      if (UNEXPECTED(ce == NULL)) {
9973
5
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9974
5
        HANDLE_EXCEPTION();
9975
5
      }
9976
10
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9977
10
        CACHE_PTR(opline->result.num, ce);
9978
10
      }
9979
10
    }
9980
38
  } else if (IS_CONST == IS_UNUSED) {
9981
0
    ce = zend_fetch_class(NULL, opline->op1.num);
9982
0
    if (UNEXPECTED(ce == NULL)) {
9983
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9984
0
      HANDLE_EXCEPTION();
9985
0
    }
9986
0
  } else {
9987
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
9988
0
  }
9989
9990
33
  if (IS_CONST == IS_CONST &&
9991
33
      (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9992
33
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
9993
    /* nothing to do */
9994
33
  } else if (IS_CONST != IS_CONST &&
9995
33
             (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9996
33
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
9997
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9998
33
  } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
9999
33
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10000
33
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10001
33
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10002
10
        do {
10003
10
          if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
10004
0
            function_name = Z_REFVAL_P(function_name);
10005
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
10006
0
              break;
10007
0
            }
10008
10
          } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
10009
0
            ZVAL_UNDEFINED_OP2();
10010
0
            if (UNEXPECTED(EG(exception) != NULL)) {
10011
0
              HANDLE_EXCEPTION();
10012
0
            }
10013
0
          }
10014
10
          zend_throw_error(NULL, "Method name must be a string");
10015
10
          zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10016
10
          HANDLE_EXCEPTION();
10017
10
        } while (0);
10018
10
      }
10019
33
    }
10020
10021
23
    if (ce->get_static_method) {
10022
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
10023
23
    } else {
10024
23
      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));
10025
23
    }
10026
23
    if (UNEXPECTED(fbc == NULL)) {
10027
2
      if (EXPECTED(!EG(exception))) {
10028
2
        zend_undefined_method(ce, Z_STR_P(function_name));
10029
2
      }
10030
2
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10031
2
      HANDLE_EXCEPTION();
10032
2
    }
10033
21
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
10034
21
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
10035
21
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
10036
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
10037
0
    }
10038
21
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10039
5
      init_func_run_time_cache(&fbc->op_array);
10040
5
    }
10041
21
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10042
21
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10043
21
    }
10044
21
  } else {
10045
0
    if (UNEXPECTED(ce->constructor == NULL)) {
10046
0
      zend_throw_error(NULL, "Cannot call constructor");
10047
0
      HANDLE_EXCEPTION();
10048
0
    }
10049
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)) {
10050
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
10051
0
      HANDLE_EXCEPTION();
10052
0
    }
10053
0
    fbc = ce->constructor;
10054
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10055
0
      init_func_run_time_cache(&fbc->op_array);
10056
0
    }
10057
0
  }
10058
10059
21
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
10060
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
10061
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
10062
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
10063
0
    } else {
10064
0
      zend_non_static_method_call(fbc);
10065
0
      HANDLE_EXCEPTION();
10066
0
    }
10067
21
  } else {
10068
    /* previous opcode is ZEND_FETCH_CLASS */
10069
21
    if (IS_CONST == IS_UNUSED
10070
21
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
10071
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
10072
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
10073
0
        ce = Z_OBJCE(EX(This));
10074
0
      } else {
10075
0
        ce = Z_CE(EX(This));
10076
0
      }
10077
0
    }
10078
21
    call_info = ZEND_CALL_NESTED_FUNCTION;
10079
21
  }
10080
10081
21
  call = zend_vm_stack_push_call_frame(call_info,
10082
21
    fbc, opline->extended_value, ce);
10083
21
  call->prev_execute_data = EX(call);
10084
21
  EX(call) = call;
10085
10086
21
  ZEND_VM_NEXT_OPCODE();
10087
21
}
10088
10089
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10090
714
{
10091
714
  USE_OPLINE
10092
714
  zval *function_name;
10093
714
  zend_fcall_info_cache fcc;
10094
714
  char *error = NULL;
10095
714
  zend_function *func;
10096
714
  void *object_or_called_scope;
10097
714
  zend_execute_data *call;
10098
714
  uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
10099
10100
714
  SAVE_OPLINE();
10101
714
  function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10102
714
  if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
10103
654
    ZEND_ASSERT(!error);
10104
10105
    /* Deprecation can be emitted from zend_is_callable_ex(), which can
10106
     * invoke a user error handler and throw an exception.
10107
     * For the CONST and CV case we reuse the same exception block below
10108
     * to make sure we don't increase VM size too much. */
10109
654
    if (!((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
10110
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10111
0
      HANDLE_EXCEPTION();
10112
0
    }
10113
10114
654
    func = fcc.function_handler;
10115
654
    object_or_called_scope = fcc.called_scope;
10116
654
    if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
10117
      /* Delay closure destruction until its invocation */
10118
44
      GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
10119
44
      call_info |= ZEND_CALL_CLOSURE;
10120
44
      if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
10121
0
        call_info |= ZEND_CALL_FAKE_CLOSURE;
10122
0
      }
10123
44
      if (fcc.object) {
10124
5
        object_or_called_scope = fcc.object;
10125
5
        call_info |= ZEND_CALL_HAS_THIS;
10126
5
      }
10127
610
    } else if (fcc.object) {
10128
605
      GC_ADDREF(fcc.object); /* For $this pointer */
10129
605
      object_or_called_scope = fcc.object;
10130
605
      call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
10131
605
    }
10132
10133
654
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10134
654
    if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
10135
0
      if (call_info & ZEND_CALL_CLOSURE) {
10136
0
        zend_object_release(ZEND_CLOSURE_OBJECT(func));
10137
0
      } else if (call_info & ZEND_CALL_RELEASE_THIS) {
10138
0
        zend_object_release(fcc.object);
10139
0
      }
10140
0
      HANDLE_EXCEPTION();
10141
0
    }
10142
10143
654
    if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
10144
81
      init_func_run_time_cache(&func->op_array);
10145
81
    }
10146
654
  } else {
10147
60
    zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
10148
60
    efree(error);
10149
60
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10150
60
    HANDLE_EXCEPTION();
10151
60
  }
10152
10153
654
  call = zend_vm_stack_push_call_frame(call_info,
10154
654
    func, opline->extended_value, object_or_called_scope);
10155
654
  call->prev_execute_data = EX(call);
10156
654
  EX(call) = call;
10157
10158
654
  ZEND_VM_NEXT_OPCODE();
10159
654
}
10160
10161
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10162
528
{
10163
528
  USE_OPLINE
10164
528
  zval *expr_ptr, new_expr;
10165
10166
528
  SAVE_OPLINE();
10167
528
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
10168
528
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
10169
0
    expr_ptr = zend_get_bad_ptr();
10170
0
    if (Z_ISREF_P(expr_ptr)) {
10171
0
      Z_ADDREF_P(expr_ptr);
10172
0
    } else {
10173
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
10174
0
    }
10175
10176
528
  } else {
10177
528
    expr_ptr = RT_CONSTANT(opline, opline->op1);
10178
528
    if (IS_CONST == IS_TMP_VAR) {
10179
      /* pass */
10180
528
    } else if (IS_CONST == IS_CONST) {
10181
528
      Z_TRY_ADDREF_P(expr_ptr);
10182
528
    } else if (IS_CONST == IS_CV) {
10183
0
      ZVAL_DEREF(expr_ptr);
10184
0
      Z_TRY_ADDREF_P(expr_ptr);
10185
0
    } else /* if (IS_CONST == IS_VAR) */ {
10186
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
10187
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
10188
10189
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
10190
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
10191
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
10192
0
          expr_ptr = &new_expr;
10193
0
          efree_size(ref, sizeof(zend_reference));
10194
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
10195
0
          Z_ADDREF_P(expr_ptr);
10196
0
        }
10197
0
      }
10198
0
    }
10199
528
  }
10200
10201
528
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10202
528
    zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10203
528
    zend_string *str;
10204
528
    zend_ulong hval;
10205
10206
528
add_again:
10207
528
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10208
478
      str = Z_STR_P(offset);
10209
478
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10210
478
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
10211
6
          goto num_index;
10212
6
        }
10213
478
      }
10214
472
str_index:
10215
472
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
10216
472
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10217
40
      hval = Z_LVAL_P(offset);
10218
48
num_index:
10219
48
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
10220
48
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
10221
0
      offset = Z_REFVAL_P(offset);
10222
0
      goto add_again;
10223
10
    } else if (Z_TYPE_P(offset) == IS_NULL) {
10224
0
      str = ZSTR_EMPTY_ALLOC();
10225
0
      goto str_index;
10226
10
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
10227
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
10228
0
      goto num_index;
10229
10
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
10230
0
      hval = 0;
10231
0
      goto num_index;
10232
10
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
10233
2
      hval = 1;
10234
2
      goto num_index;
10235
8
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
10236
0
      zend_use_resource_as_offset(offset);
10237
0
      hval = Z_RES_HANDLE_P(offset);
10238
0
      goto num_index;
10239
8
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
10240
0
      ZVAL_UNDEFINED_OP2();
10241
0
      str = ZSTR_EMPTY_ALLOC();
10242
0
      goto str_index;
10243
8
    } else {
10244
8
      zend_illegal_array_offset_access(offset);
10245
8
      zval_ptr_dtor_nogc(expr_ptr);
10246
8
    }
10247
528
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10248
528
  } else {
10249
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
10250
0
      zend_cannot_add_element();
10251
0
      zval_ptr_dtor_nogc(expr_ptr);
10252
0
    }
10253
0
  }
10254
528
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10255
528
}
10256
10257
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10258
160
{
10259
160
  zval *array;
10260
160
  uint32_t size;
10261
160
  USE_OPLINE
10262
10263
160
  SAVE_OPLINE();
10264
160
  array = EX_VAR(opline->result.var);
10265
160
  if (IS_CONST != IS_UNUSED) {
10266
160
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
10267
160
    ZVAL_ARR(array, zend_new_array(size));
10268
    /* Explicitly initialize array as not-packed if flag is set */
10269
160
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
10270
90
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
10271
90
    }
10272
160
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10273
160
  } else {
10274
0
    ZVAL_ARR(array, zend_new_array(0));
10275
0
    ZEND_VM_NEXT_OPCODE();
10276
0
  }
10277
160
}
10278
10279
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10280
0
{
10281
0
  USE_OPLINE
10282
0
  zval *container;
10283
0
  bool result;
10284
0
  zend_ulong hval;
10285
0
  zval *offset;
10286
10287
0
  SAVE_OPLINE();
10288
0
  container = RT_CONSTANT(opline, opline->op1);
10289
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10290
10291
0
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
10292
0
    HashTable *ht;
10293
0
    zval *value;
10294
0
    zend_string *str;
10295
10296
0
isset_dim_obj_array:
10297
0
    ht = Z_ARRVAL_P(container);
10298
0
isset_again:
10299
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10300
0
      str = Z_STR_P(offset);
10301
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10302
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
10303
0
          goto num_index_prop;
10304
0
        }
10305
0
      }
10306
0
      value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
10307
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10308
0
      hval = Z_LVAL_P(offset);
10309
0
num_index_prop:
10310
0
      value = zend_hash_index_find(ht, hval);
10311
0
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
10312
0
      offset = Z_REFVAL_P(offset);
10313
0
      goto isset_again;
10314
0
    } else {
10315
0
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
10316
0
      if (UNEXPECTED(EG(exception))) {
10317
0
        result = 0;
10318
0
        goto isset_dim_obj_exit;
10319
0
      }
10320
0
    }
10321
10322
0
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
10323
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
10324
0
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
10325
0
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
10326
10327
0
      if (IS_CONST & (IS_CONST|IS_CV)) {
10328
        /* avoid exception check */
10329
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10330
0
        ZEND_VM_SMART_BRANCH(result, 0);
10331
0
      }
10332
0
    } else {
10333
0
      result = (value == NULL || !i_zend_is_true(value));
10334
0
    }
10335
0
    goto isset_dim_obj_exit;
10336
0
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
10337
0
    container = Z_REFVAL_P(container);
10338
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
10339
0
      goto isset_dim_obj_array;
10340
0
    }
10341
0
  }
10342
10343
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
10344
0
    offset++;
10345
0
  }
10346
0
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
10347
0
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
10348
0
  } else {
10349
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
10350
0
  }
10351
10352
0
isset_dim_obj_exit:
10353
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10354
10355
0
  ZEND_VM_SMART_BRANCH(result, 1);
10356
0
}
10357
10358
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10359
0
{
10360
0
  USE_OPLINE
10361
0
  zval *container;
10362
0
  int result;
10363
0
  zval *offset;
10364
0
  zend_string *name, *tmp_name;
10365
10366
0
  SAVE_OPLINE();
10367
0
  container = RT_CONSTANT(opline, opline->op1);
10368
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10369
10370
0
  if (IS_CONST == IS_CONST ||
10371
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
10372
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
10373
0
      container = Z_REFVAL_P(container);
10374
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
10375
0
        result = (opline->extended_value & ZEND_ISEMPTY);
10376
0
        goto isset_object_finish;
10377
0
      }
10378
0
    } else {
10379
0
      result = (opline->extended_value & ZEND_ISEMPTY);
10380
0
      goto isset_object_finish;
10381
0
    }
10382
0
  }
10383
10384
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
10385
0
    name = Z_STR_P(offset);
10386
0
  } else {
10387
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
10388
0
    if (UNEXPECTED(!name)) {
10389
0
      result = 0;
10390
0
      goto isset_object_finish;
10391
0
    }
10392
0
  }
10393
10394
0
  result =
10395
0
    (opline->extended_value & ZEND_ISEMPTY) ^
10396
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));
10397
10398
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10399
0
    zend_tmp_string_release(tmp_name);
10400
0
  }
10401
10402
0
isset_object_finish:
10403
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10404
10405
0
  ZEND_VM_SMART_BRANCH(result, 1);
10406
0
}
10407
10408
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10409
9
{
10410
9
  USE_OPLINE
10411
10412
9
  zval *key, *subject;
10413
9
  HashTable *ht;
10414
9
  bool result;
10415
10416
9
  SAVE_OPLINE();
10417
10418
9
  key = RT_CONSTANT(opline, opline->op1);
10419
9
  subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10420
10421
9
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10422
0
array_key_exists_array:
10423
0
    ht = Z_ARRVAL_P(subject);
10424
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
10425
9
  } else {
10426
9
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
10427
0
      subject = Z_REFVAL_P(subject);
10428
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10429
0
        goto array_key_exists_array;
10430
0
      }
10431
0
    }
10432
9
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
10433
9
    result = 0;
10434
9
  }
10435
10436
9
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10437
10438
9
  ZEND_VM_SMART_BRANCH(result, 1);
10439
9
}
10440
10441
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10442
8
{
10443
8
  USE_OPLINE
10444
10445
8
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
10446
10447
8
  SAVE_OPLINE();
10448
8
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
10449
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10450
0
  }
10451
10452
  /* Destroy the previously yielded value */
10453
8
  zval_ptr_dtor(&generator->value);
10454
10455
  /* Destroy the previously yielded key */
10456
8
  zval_ptr_dtor(&generator->key);
10457
10458
  /* Set the new yielded value */
10459
8
  if (IS_CONST != IS_UNUSED) {
10460
8
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10461
      /* Constants and temporary variables aren't yieldable by reference,
10462
       * but we still allow them with a notice. */
10463
0
      if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
10464
0
        zval *value;
10465
10466
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10467
10468
0
        value = RT_CONSTANT(opline, opline->op1);
10469
0
        ZVAL_COPY_VALUE(&generator->value, value);
10470
0
        if (IS_CONST == IS_CONST) {
10471
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10472
0
            Z_ADDREF(generator->value);
10473
0
          }
10474
0
        }
10475
0
      } else {
10476
0
        zval *value_ptr = zend_get_bad_ptr();
10477
10478
        /* If a function call result is yielded and the function did
10479
         * not return by reference we throw a notice. */
10480
0
        do {
10481
0
          if (IS_CONST == IS_VAR) {
10482
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
10483
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
10484
0
             && !Z_ISREF_P(value_ptr)) {
10485
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10486
0
              ZVAL_COPY(&generator->value, value_ptr);
10487
0
              break;
10488
0
            }
10489
0
          }
10490
0
          if (Z_ISREF_P(value_ptr)) {
10491
0
            Z_ADDREF_P(value_ptr);
10492
0
          } else {
10493
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
10494
0
          }
10495
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
10496
0
        } while (0);
10497
10498
0
      }
10499
8
    } else {
10500
8
      zval *value = RT_CONSTANT(opline, opline->op1);
10501
10502
      /* Consts, temporary variables and references need copying */
10503
8
      if (IS_CONST == IS_CONST) {
10504
8
        ZVAL_COPY_VALUE(&generator->value, value);
10505
8
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10506
0
          Z_ADDREF(generator->value);
10507
0
        }
10508
8
      } else if (IS_CONST == IS_TMP_VAR) {
10509
0
        ZVAL_COPY_VALUE(&generator->value, value);
10510
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
10511
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
10512
10513
0
      } else {
10514
0
        ZVAL_COPY_VALUE(&generator->value, value);
10515
0
        if (IS_CONST == IS_CV) {
10516
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
10517
0
        }
10518
0
      }
10519
8
    }
10520
8
  } else {
10521
    /* If no value was specified yield null */
10522
0
    ZVAL_NULL(&generator->value);
10523
0
  }
10524
10525
  /* Set the new yielded key */
10526
8
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10527
8
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10528
8
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
10529
0
      key = Z_REFVAL_P(key);
10530
0
    }
10531
8
    ZVAL_COPY(&generator->key, key);
10532
8
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10533
10534
8
    if (Z_TYPE(generator->key) == IS_LONG
10535
8
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
10536
8
    ) {
10537
8
      generator->largest_used_integer_key = Z_LVAL(generator->key);
10538
8
    }
10539
8
  } else {
10540
    /* If no key was specified we use auto-increment keys */
10541
0
    generator->largest_used_integer_key++;
10542
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
10543
0
  }
10544
10545
8
  if (RETURN_VALUE_USED(opline)) {
10546
    /* If the return value of yield is used set the send
10547
     * target and initialize it to NULL */
10548
0
    generator->send_target = EX_VAR(opline->result.var);
10549
0
    ZVAL_NULL(generator->send_target);
10550
8
  } else {
10551
8
    generator->send_target = NULL;
10552
8
  }
10553
10554
  /* The GOTO VM uses a local opline variable. We need to set the opline
10555
   * variable in execute_data so we don't resume at an old position. */
10556
8
  SAVE_OPLINE();
10557
10558
8
  ZEND_VM_RETURN();
10559
8
}
10560
10561
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)
10562
1.43k
{
10563
1.43k
  USE_OPLINE
10564
1.43k
  zval *varname;
10565
1.43k
  zval *retval;
10566
1.43k
  zend_string *name, *tmp_name;
10567
1.43k
  HashTable *target_symbol_table;
10568
10569
1.43k
  SAVE_OPLINE();
10570
1.43k
  varname = RT_CONSTANT(opline, opline->op1);
10571
10572
1.43k
  if (IS_CONST == IS_CONST) {
10573
1.43k
    name = Z_STR_P(varname);
10574
1.43k
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
10575
0
    name = Z_STR_P(varname);
10576
0
    tmp_name = NULL;
10577
0
  } else {
10578
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
10579
0
      ZVAL_UNDEFINED_OP1();
10580
0
    }
10581
0
    name = zval_try_get_tmp_string(varname, &tmp_name);
10582
0
    if (UNEXPECTED(!name)) {
10583
0
      if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10584
10585
0
      }
10586
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
10587
0
      HANDLE_EXCEPTION();
10588
0
    }
10589
0
  }
10590
10591
1.43k
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10592
1.43k
  retval = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
10593
1.43k
  if (retval == NULL) {
10594
300
    if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10595
83
fetch_this:
10596
83
      zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
10597
83
      if (IS_CONST != IS_CONST) {
10598
0
        zend_tmp_string_release(tmp_name);
10599
0
      }
10600
83
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10601
83
    }
10602
217
    if (type == BP_VAR_W) {
10603
33
      retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
10604
184
    } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10605
22
      retval = &EG(uninitialized_zval);
10606
162
    } else {
10607
162
      if (IS_CONST == IS_CV) {
10608
        /* Keep name alive in case an error handler tries to free it. */
10609
0
        zend_string_addref(name);
10610
0
      }
10611
162
      zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10612
162
        (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10613
162
      if (type == BP_VAR_RW && !EG(exception)) {
10614
0
        retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
10615
162
      } else {
10616
162
        retval = &EG(uninitialized_zval);
10617
162
      }
10618
162
      if (IS_CONST == IS_CV) {
10619
0
        zend_string_release(name);
10620
0
      }
10621
162
    }
10622
  /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
10623
1.13k
  } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
10624
924
    retval = Z_INDIRECT_P(retval);
10625
924
    if (Z_TYPE_P(retval) == IS_UNDEF) {
10626
107
      if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10627
0
        goto fetch_this;
10628
0
      }
10629
107
      if (type == BP_VAR_W) {
10630
26
        ZVAL_NULL(retval);
10631
81
      } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10632
0
        retval = &EG(uninitialized_zval);
10633
81
      } else {
10634
81
        zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10635
81
          (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10636
81
        if (type == BP_VAR_RW && !EG(exception)) {
10637
2
          ZVAL_NULL(retval);
10638
79
        } else {
10639
79
          retval = &EG(uninitialized_zval);
10640
79
        }
10641
81
      }
10642
107
    }
10643
924
  }
10644
10645
1.35k
  if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10646
10647
1.35k
  }
10648
10649
1.35k
  if (IS_CONST != IS_CONST) {
10650
0
    zend_tmp_string_release(tmp_name);
10651
0
  }
10652
10653
1.35k
  ZEND_ASSERT(retval != NULL);
10654
1.35k
  if (type == BP_VAR_R || type == BP_VAR_IS) {
10655
540
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
10656
811
  } else {
10657
811
    ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
10658
811
  }
10659
1.35k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10660
1.35k
}
10661
10662
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10663
606
{
10664
606
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R));
10665
606
}
10666
10667
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10668
765
{
10669
765
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W));
10670
765
}
10671
10672
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10673
18
{
10674
18
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW));
10675
18
}
10676
10677
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10678
0
{
10679
0
  int fetch_type =
10680
0
    (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
10681
0
      BP_VAR_W : BP_VAR_R;
10682
0
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type));
10683
0
}
10684
10685
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10686
28
{
10687
28
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET));
10688
28
}
10689
10690
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10691
17
{
10692
17
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS));
10693
17
}
10694
10695
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
10696
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10697
0
{
10698
#if 0
10699
  USE_OPLINE
10700
#endif
10701
10702
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
10703
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
10704
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_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
  } else {
10708
0
    if (IS_UNUSED == IS_UNUSED) {
10709
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10710
0
    }
10711
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10712
0
  }
10713
0
}
10714
10715
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10716
10
{
10717
10
  USE_OPLINE
10718
10
  zval *function_name;
10719
10
  zend_class_entry *ce;
10720
10
  uint32_t call_info;
10721
10
  zend_function *fbc;
10722
10
  zend_execute_data *call;
10723
10724
10
  SAVE_OPLINE();
10725
10726
10
  if (IS_CONST == IS_CONST) {
10727
    /* no function found. try a static method in class */
10728
10
    ce = CACHED_PTR(opline->result.num);
10729
10
    if (UNEXPECTED(ce == NULL)) {
10730
10
      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);
10731
10
      if (UNEXPECTED(ce == NULL)) {
10732
10733
5
        HANDLE_EXCEPTION();
10734
5
      }
10735
5
      if (IS_UNUSED != IS_CONST) {
10736
5
        CACHE_PTR(opline->result.num, ce);
10737
5
      }
10738
5
    }
10739
10
  } else if (IS_CONST == IS_UNUSED) {
10740
0
    ce = zend_fetch_class(NULL, opline->op1.num);
10741
0
    if (UNEXPECTED(ce == NULL)) {
10742
10743
0
      HANDLE_EXCEPTION();
10744
0
    }
10745
0
  } else {
10746
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
10747
0
  }
10748
10749
5
  if (IS_CONST == IS_CONST &&
10750
5
      IS_UNUSED == IS_CONST &&
10751
5
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
10752
    /* nothing to do */
10753
5
  } else if (IS_CONST != IS_CONST &&
10754
5
             IS_UNUSED == IS_CONST &&
10755
5
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
10756
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
10757
5
  } else if (IS_UNUSED != IS_UNUSED) {
10758
0
    function_name = NULL;
10759
0
    if (IS_UNUSED != IS_CONST) {
10760
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10761
0
        do {
10762
0
          if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
10763
0
            function_name = Z_REFVAL_P(function_name);
10764
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
10765
0
              break;
10766
0
            }
10767
0
          } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
10768
0
            ZVAL_UNDEFINED_OP2();
10769
0
            if (UNEXPECTED(EG(exception) != NULL)) {
10770
0
              HANDLE_EXCEPTION();
10771
0
            }
10772
0
          }
10773
0
          zend_throw_error(NULL, "Method name must be a string");
10774
10775
0
          HANDLE_EXCEPTION();
10776
0
        } while (0);
10777
0
      }
10778
0
    }
10779
10780
0
    if (ce->get_static_method) {
10781
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
10782
0
    } else {
10783
0
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
10784
0
    }
10785
0
    if (UNEXPECTED(fbc == NULL)) {
10786
0
      if (EXPECTED(!EG(exception))) {
10787
0
        zend_undefined_method(ce, Z_STR_P(function_name));
10788
0
      }
10789
10790
0
      HANDLE_EXCEPTION();
10791
0
    }
10792
0
    if (IS_UNUSED == IS_CONST &&
10793
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
10794
0
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
10795
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
10796
0
    }
10797
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10798
0
      init_func_run_time_cache(&fbc->op_array);
10799
0
    }
10800
0
    if (IS_UNUSED != IS_CONST) {
10801
10802
0
    }
10803
5
  } else {
10804
5
    if (UNEXPECTED(ce->constructor == NULL)) {
10805
5
      zend_throw_error(NULL, "Cannot call constructor");
10806
5
      HANDLE_EXCEPTION();
10807
5
    }
10808
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)) {
10809
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
10810
0
      HANDLE_EXCEPTION();
10811
0
    }
10812
0
    fbc = ce->constructor;
10813
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10814
0
      init_func_run_time_cache(&fbc->op_array);
10815
0
    }
10816
0
  }
10817
10818
0
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
10819
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
10820
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
10821
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
10822
0
    } else {
10823
0
      zend_non_static_method_call(fbc);
10824
0
      HANDLE_EXCEPTION();
10825
0
    }
10826
0
  } else {
10827
    /* previous opcode is ZEND_FETCH_CLASS */
10828
0
    if (IS_CONST == IS_UNUSED
10829
0
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
10830
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
10831
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
10832
0
        ce = Z_OBJCE(EX(This));
10833
0
      } else {
10834
0
        ce = Z_CE(EX(This));
10835
0
      }
10836
0
    }
10837
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
10838
0
  }
10839
10840
0
  call = zend_vm_stack_push_call_frame(call_info,
10841
0
    fbc, opline->extended_value, ce);
10842
0
  call->prev_execute_data = EX(call);
10843
0
  EX(call) = call;
10844
10845
0
  ZEND_VM_NEXT_OPCODE();
10846
0
}
10847
10848
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10849
145
{
10850
145
  if (IS_CONST == IS_UNUSED) {
10851
0
    SAVE_OPLINE();
10852
0
    zend_verify_missing_return_type(EX(func));
10853
0
    HANDLE_EXCEPTION();
10854
145
  } else {
10855
/* prevents "undefined variable opline" errors */
10856
145
#if 0 || (IS_CONST != IS_UNUSED)
10857
145
    USE_OPLINE
10858
145
    zval *retval_ref, *retval_ptr;
10859
145
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
10860
145
    retval_ref = retval_ptr = RT_CONSTANT(opline, opline->op1);
10861
10862
145
    if (IS_CONST == IS_CONST) {
10863
145
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
10864
145
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
10865
145
    } else if (IS_CONST == IS_VAR) {
10866
0
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
10867
0
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
10868
0
      }
10869
0
      ZVAL_DEREF(retval_ptr);
10870
0
    } else if (IS_CONST == IS_CV) {
10871
0
      ZVAL_DEREF(retval_ptr);
10872
0
    }
10873
10874
145
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
10875
0
      ZEND_VM_NEXT_OPCODE();
10876
0
    }
10877
10878
145
    if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
10879
0
      SAVE_OPLINE();
10880
0
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
10881
0
      if (UNEXPECTED(EG(exception))) {
10882
0
        HANDLE_EXCEPTION();
10883
0
      }
10884
0
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
10885
0
        ZEND_VM_NEXT_OPCODE();
10886
0
      }
10887
0
    }
10888
10889
145
    zend_reference *ref = NULL;
10890
145
    if (UNEXPECTED(retval_ref != retval_ptr)) {
10891
0
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10892
0
        ref = Z_REF_P(retval_ref);
10893
0
      } else {
10894
        /* A cast might happen - unwrap the reference if this is a by-value return */
10895
0
        if (Z_REFCOUNT_P(retval_ref) == 1) {
10896
0
          ZVAL_UNREF(retval_ref);
10897
0
        } else {
10898
0
          Z_DELREF_P(retval_ref);
10899
0
          ZVAL_COPY(retval_ref, retval_ptr);
10900
0
        }
10901
0
        retval_ptr = retval_ref;
10902
0
      }
10903
0
    }
10904
10905
145
    SAVE_OPLINE();
10906
145
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
10907
114
      zend_verify_return_error(EX(func), retval_ptr);
10908
114
      HANDLE_EXCEPTION();
10909
114
    }
10910
31
    ZEND_VM_NEXT_OPCODE();
10911
31
#endif
10912
31
  }
10913
145
}
10914
10915
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10916
3.07k
{
10917
3.07k
  USE_OPLINE
10918
3.07k
  zval *value, *arg;
10919
10920
3.07k
  if (IS_UNUSED == IS_CONST) {
10921
0
    SAVE_OPLINE();
10922
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10923
0
    uint32_t arg_num;
10924
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10925
0
    if (UNEXPECTED(!arg)) {
10926
10927
0
      HANDLE_EXCEPTION();
10928
0
    }
10929
3.07k
  } else {
10930
3.07k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10931
3.07k
  }
10932
10933
3.07k
  value = RT_CONSTANT(opline, opline->op1);
10934
3.07k
  ZVAL_COPY_VALUE(arg, value);
10935
3.07k
  if (IS_CONST == IS_CONST) {
10936
3.07k
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10937
43
      Z_ADDREF_P(arg);
10938
43
    }
10939
3.07k
  }
10940
3.07k
  ZEND_VM_NEXT_OPCODE();
10941
3.07k
}
10942
10943
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10944
0
{
10945
0
  USE_OPLINE
10946
0
  zval *value, *arg;
10947
0
  uint32_t arg_num;
10948
10949
0
  if (IS_UNUSED == IS_CONST) {
10950
0
    SAVE_OPLINE();
10951
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10952
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10953
0
    if (UNEXPECTED(!arg)) {
10954
10955
0
      HANDLE_EXCEPTION();
10956
0
    }
10957
0
  } else {
10958
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10959
0
    arg_num = opline->op2.num;
10960
0
  }
10961
10962
0
  if (EXPECTED(0)) {
10963
0
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10964
0
      goto send_val_by_ref;
10965
0
    }
10966
0
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10967
0
send_val_by_ref:
10968
0
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
10969
0
  }
10970
0
  value = RT_CONSTANT(opline, opline->op1);
10971
0
  ZVAL_COPY_VALUE(arg, value);
10972
0
  if (IS_CONST == IS_CONST) {
10973
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10974
0
      Z_ADDREF_P(arg);
10975
0
    }
10976
0
  }
10977
0
  ZEND_VM_NEXT_OPCODE();
10978
0
}
10979
10980
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10981
1.52k
{
10982
1.52k
  USE_OPLINE
10983
1.52k
  zval *value, *arg;
10984
1.52k
  uint32_t arg_num;
10985
10986
1.52k
  if (IS_UNUSED == IS_CONST) {
10987
0
    SAVE_OPLINE();
10988
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10989
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10990
0
    if (UNEXPECTED(!arg)) {
10991
10992
0
      HANDLE_EXCEPTION();
10993
0
    }
10994
1.52k
  } else {
10995
1.52k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10996
1.52k
    arg_num = opline->op2.num;
10997
1.52k
  }
10998
10999
1.52k
  if (EXPECTED(1)) {
11000
1.52k
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
11001
1
      goto send_val_by_ref;
11002
1
    }
11003
1.52k
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
11004
1
send_val_by_ref:
11005
1
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
11006
0
  }
11007
1.52k
  value = RT_CONSTANT(opline, opline->op1);
11008
1.52k
  ZVAL_COPY_VALUE(arg, value);
11009
1.52k
  if (IS_CONST == IS_CONST) {
11010
1.52k
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
11011
15
      Z_ADDREF_P(arg);
11012
15
    }
11013
1.52k
  }
11014
1.52k
  ZEND_VM_NEXT_OPCODE();
11015
1.52k
}
11016
11017
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11018
980k
{
11019
980k
  USE_OPLINE
11020
980k
  zval *result;
11021
980k
  zend_function *constructor;
11022
980k
  zend_class_entry *ce;
11023
980k
  zend_execute_data *call;
11024
11025
980k
  SAVE_OPLINE();
11026
980k
  if (IS_CONST == IS_CONST) {
11027
980k
    ce = CACHED_PTR(opline->op2.num);
11028
980k
    if (UNEXPECTED(ce == NULL)) {
11029
201k
      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);
11030
201k
      if (UNEXPECTED(ce == NULL)) {
11031
1.57k
        ZVAL_UNDEF(EX_VAR(opline->result.var));
11032
1.57k
        HANDLE_EXCEPTION();
11033
1.57k
      }
11034
199k
      CACHE_PTR(opline->op2.num, ce);
11035
199k
    }
11036
980k
  } else if (IS_CONST == IS_UNUSED) {
11037
0
    ce = zend_fetch_class(NULL, opline->op1.num);
11038
0
    if (UNEXPECTED(ce == NULL)) {
11039
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
11040
0
      HANDLE_EXCEPTION();
11041
0
    }
11042
0
  } else {
11043
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
11044
0
  }
11045
11046
979k
  result = EX_VAR(opline->result.var);
11047
979k
  if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
11048
101
    ZVAL_UNDEF(result);
11049
101
    HANDLE_EXCEPTION();
11050
101
  }
11051
11052
979k
  constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
11053
979k
  if (constructor == NULL) {
11054
    /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
11055
     * opcode is DO_FCALL in case EXT instructions are used. */
11056
310k
    if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
11057
310k
      ZEND_VM_NEXT_OPCODE_EX(1, 2);
11058
310k
    }
11059
11060
184
    if (UNEXPECTED(EG(exception))) {
11061
5
      HANDLE_EXCEPTION();
11062
5
    }
11063
11064
    /* Perform a dummy function call */
11065
179
    call = zend_vm_stack_push_call_frame(
11066
179
      ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
11067
179
      opline->extended_value, NULL);
11068
668k
  } else {
11069
668k
    if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
11070
2.15k
      init_func_run_time_cache(&constructor->op_array);
11071
2.15k
    }
11072
    /* We are not handling overloaded classes right now */
11073
668k
    call = zend_vm_stack_push_call_frame(
11074
668k
      ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
11075
668k
      constructor,
11076
668k
      opline->extended_value,
11077
668k
      Z_OBJ_P(result));
11078
668k
    Z_ADDREF_P(result);
11079
668k
  }
11080
11081
668k
  call->prev_execute_data = EX(call);
11082
668k
  EX(call) = call;
11083
668k
  ZEND_VM_NEXT_OPCODE();
11084
668k
}
11085
11086
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11087
31.3k
{
11088
31.3k
  USE_OPLINE
11089
31.3k
  zval *expr_ptr, new_expr;
11090
11091
31.3k
  SAVE_OPLINE();
11092
31.3k
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
11093
31.3k
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
11094
0
    expr_ptr = zend_get_bad_ptr();
11095
0
    if (Z_ISREF_P(expr_ptr)) {
11096
0
      Z_ADDREF_P(expr_ptr);
11097
0
    } else {
11098
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
11099
0
    }
11100
11101
31.3k
  } else {
11102
31.3k
    expr_ptr = RT_CONSTANT(opline, opline->op1);
11103
31.3k
    if (IS_CONST == IS_TMP_VAR) {
11104
      /* pass */
11105
31.3k
    } else if (IS_CONST == IS_CONST) {
11106
31.3k
      Z_TRY_ADDREF_P(expr_ptr);
11107
31.3k
    } else if (IS_CONST == IS_CV) {
11108
0
      ZVAL_DEREF(expr_ptr);
11109
0
      Z_TRY_ADDREF_P(expr_ptr);
11110
0
    } else /* if (IS_CONST == IS_VAR) */ {
11111
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
11112
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
11113
11114
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
11115
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
11116
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
11117
0
          expr_ptr = &new_expr;
11118
0
          efree_size(ref, sizeof(zend_reference));
11119
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
11120
0
          Z_ADDREF_P(expr_ptr);
11121
0
        }
11122
0
      }
11123
0
    }
11124
31.3k
  }
11125
11126
31.3k
  if (IS_UNUSED != IS_UNUSED) {
11127
0
    zval *offset = NULL;
11128
0
    zend_string *str;
11129
0
    zend_ulong hval;
11130
11131
0
add_again:
11132
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
11133
0
      str = Z_STR_P(offset);
11134
0
      if (IS_UNUSED != IS_CONST) {
11135
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
11136
0
          goto num_index;
11137
0
        }
11138
0
      }
11139
0
str_index:
11140
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
11141
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
11142
0
      hval = Z_LVAL_P(offset);
11143
0
num_index:
11144
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
11145
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
11146
0
      offset = Z_REFVAL_P(offset);
11147
0
      goto add_again;
11148
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
11149
0
      str = ZSTR_EMPTY_ALLOC();
11150
0
      goto str_index;
11151
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
11152
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
11153
0
      goto num_index;
11154
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
11155
0
      hval = 0;
11156
0
      goto num_index;
11157
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
11158
0
      hval = 1;
11159
0
      goto num_index;
11160
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
11161
0
      zend_use_resource_as_offset(offset);
11162
0
      hval = Z_RES_HANDLE_P(offset);
11163
0
      goto num_index;
11164
0
    } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
11165
0
      ZVAL_UNDEFINED_OP2();
11166
0
      str = ZSTR_EMPTY_ALLOC();
11167
0
      goto str_index;
11168
0
    } else {
11169
0
      zend_illegal_array_offset_access(offset);
11170
0
      zval_ptr_dtor_nogc(expr_ptr);
11171
0
    }
11172
11173
31.3k
  } else {
11174
31.3k
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
11175
20
      zend_cannot_add_element();
11176
20
      zval_ptr_dtor_nogc(expr_ptr);
11177
20
    }
11178
31.3k
  }
11179
31.3k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11180
31.3k
}
11181
11182
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11183
1.68k
{
11184
1.68k
  zval *array;
11185
1.68k
  uint32_t size;
11186
1.68k
  USE_OPLINE
11187
11188
1.68k
  SAVE_OPLINE();
11189
1.68k
  array = EX_VAR(opline->result.var);
11190
1.68k
  if (IS_CONST != IS_UNUSED) {
11191
1.68k
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
11192
1.68k
    ZVAL_ARR(array, zend_new_array(size));
11193
    /* Explicitly initialize array as not-packed if flag is set */
11194
1.68k
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
11195
30
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
11196
30
    }
11197
1.68k
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11198
1.68k
  } else {
11199
0
    ZVAL_ARR(array, zend_new_array(0));
11200
0
    ZEND_VM_NEXT_OPCODE();
11201
0
  }
11202
1.68k
}
11203
11204
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11205
49
{
11206
49
  USE_OPLINE
11207
49
  zval *varname;
11208
49
  zend_string *name, *tmp_name;
11209
49
  HashTable *target_symbol_table;
11210
11211
49
  SAVE_OPLINE();
11212
11213
49
  varname = RT_CONSTANT(opline, opline->op1);
11214
11215
49
  if (IS_CONST == IS_CONST) {
11216
49
    name = Z_STR_P(varname);
11217
49
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
11218
0
    name = Z_STR_P(varname);
11219
0
    tmp_name = NULL;
11220
0
  } else {
11221
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
11222
0
      varname = ZVAL_UNDEFINED_OP1();
11223
0
    }
11224
0
    name = zval_try_get_tmp_string(varname, &tmp_name);
11225
0
    if (UNEXPECTED(!name)) {
11226
11227
0
      HANDLE_EXCEPTION();
11228
0
    }
11229
0
  }
11230
11231
49
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
11232
49
  zend_hash_del_ind(target_symbol_table, name);
11233
11234
49
  if (IS_CONST != IS_CONST) {
11235
0
    zend_tmp_string_release(tmp_name);
11236
0
  }
11237
11238
49
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11239
49
}
11240
11241
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
11242
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11243
110
{
11244
110
  USE_OPLINE
11245
110
  zval *value;
11246
110
  bool result;
11247
110
  zval *varname;
11248
110
  zend_string *name, *tmp_name;
11249
110
  HashTable *target_symbol_table;
11250
11251
110
  SAVE_OPLINE();
11252
110
  varname = RT_CONSTANT(opline, opline->op1);
11253
110
  if (IS_CONST == IS_CONST) {
11254
110
    name = Z_STR_P(varname);
11255
110
  } else {
11256
0
    name = zval_get_tmp_string(varname, &tmp_name);
11257
0
  }
11258
11259
110
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
11260
110
  value = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
11261
11262
110
  if (IS_CONST != IS_CONST) {
11263
0
    zend_tmp_string_release(tmp_name);
11264
0
  }
11265
11266
110
  if (!value) {
11267
14
    result = (opline->extended_value & ZEND_ISEMPTY);
11268
96
  } else {
11269
96
    if (Z_TYPE_P(value) == IS_INDIRECT) {
11270
23
      value = Z_INDIRECT_P(value);
11271
23
    }
11272
96
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
11273
59
      if (Z_ISREF_P(value)) {
11274
0
        value = Z_REFVAL_P(value);
11275
0
      }
11276
59
      result = Z_TYPE_P(value) > IS_NULL;
11277
59
    } else {
11278
37
      result = !i_zend_is_true(value);
11279
37
    }
11280
96
  }
11281
11282
110
  ZEND_VM_SMART_BRANCH(result, true);
11283
110
}
11284
11285
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
11286
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11287
743
{
11288
743
  USE_OPLINE
11289
11290
743
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
11291
11292
743
  SAVE_OPLINE();
11293
743
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
11294
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11295
0
  }
11296
11297
  /* Destroy the previously yielded value */
11298
743
  zval_ptr_dtor(&generator->value);
11299
11300
  /* Destroy the previously yielded key */
11301
743
  zval_ptr_dtor(&generator->key);
11302
11303
  /* Set the new yielded value */
11304
743
  if (IS_CONST != IS_UNUSED) {
11305
743
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
11306
      /* Constants and temporary variables aren't yieldable by reference,
11307
       * but we still allow them with a notice. */
11308
5
      if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
11309
5
        zval *value;
11310
11311
5
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11312
11313
5
        value = RT_CONSTANT(opline, opline->op1);
11314
5
        ZVAL_COPY_VALUE(&generator->value, value);
11315
5
        if (IS_CONST == IS_CONST) {
11316
5
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
11317
0
            Z_ADDREF(generator->value);
11318
0
          }
11319
5
        }
11320
5
      } else {
11321
0
        zval *value_ptr = zend_get_bad_ptr();
11322
11323
        /* If a function call result is yielded and the function did
11324
         * not return by reference we throw a notice. */
11325
0
        do {
11326
0
          if (IS_CONST == IS_VAR) {
11327
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
11328
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
11329
0
             && !Z_ISREF_P(value_ptr)) {
11330
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11331
0
              ZVAL_COPY(&generator->value, value_ptr);
11332
0
              break;
11333
0
            }
11334
0
          }
11335
0
          if (Z_ISREF_P(value_ptr)) {
11336
0
            Z_ADDREF_P(value_ptr);
11337
0
          } else {
11338
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
11339
0
          }
11340
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
11341
0
        } while (0);
11342
11343
0
      }
11344
738
    } else {
11345
738
      zval *value = RT_CONSTANT(opline, opline->op1);
11346
11347
      /* Consts, temporary variables and references need copying */
11348
738
      if (IS_CONST == IS_CONST) {
11349
738
        ZVAL_COPY_VALUE(&generator->value, value);
11350
738
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
11351
0
          Z_ADDREF(generator->value);
11352
0
        }
11353
738
      } else if (IS_CONST == IS_TMP_VAR) {
11354
0
        ZVAL_COPY_VALUE(&generator->value, value);
11355
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
11356
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
11357
11358
0
      } else {
11359
0
        ZVAL_COPY_VALUE(&generator->value, value);
11360
0
        if (IS_CONST == IS_CV) {
11361
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
11362
0
        }
11363
0
      }
11364
738
    }
11365
743
  } else {
11366
    /* If no value was specified yield null */
11367
0
    ZVAL_NULL(&generator->value);
11368
0
  }
11369
11370
  /* Set the new yielded key */
11371
743
  if (IS_UNUSED != IS_UNUSED) {
11372
0
    zval *key = NULL;
11373
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
11374
0
      key = Z_REFVAL_P(key);
11375
0
    }
11376
0
    ZVAL_COPY(&generator->key, key);
11377
11378
0
    if (Z_TYPE(generator->key) == IS_LONG
11379
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
11380
0
    ) {
11381
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
11382
0
    }
11383
743
  } else {
11384
    /* If no key was specified we use auto-increment keys */
11385
743
    generator->largest_used_integer_key++;
11386
743
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
11387
743
  }
11388
11389
743
  if (RETURN_VALUE_USED(opline)) {
11390
    /* If the return value of yield is used set the send
11391
     * target and initialize it to NULL */
11392
67
    generator->send_target = EX_VAR(opline->result.var);
11393
67
    ZVAL_NULL(generator->send_target);
11394
676
  } else {
11395
676
    generator->send_target = NULL;
11396
676
  }
11397
11398
  /* The GOTO VM uses a local opline variable. We need to set the opline
11399
   * variable in execute_data so we don't resume at an old position. */
11400
743
  SAVE_OPLINE();
11401
11402
743
  ZEND_VM_RETURN();
11403
743
}
11404
11405
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11406
50
{
11407
50
  USE_OPLINE
11408
50
  zval *op;
11409
11410
50
  SAVE_OPLINE();
11411
50
  op = RT_CONSTANT(opline, opline->op1);
11412
50
  zend_match_unhandled_error(op);
11413
50
  HANDLE_EXCEPTION();
11414
50
}
11415
11416
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11417
2
{
11418
2
  USE_OPLINE
11419
2
  zval *op1;
11420
2
  zend_long count;
11421
11422
2
  SAVE_OPLINE();
11423
2
  op1 = RT_CONSTANT(opline, opline->op1);
11424
11425
2
  while (1) {
11426
2
    if (Z_TYPE_P(op1) == IS_ARRAY) {
11427
0
      count = zend_hash_num_elements(Z_ARRVAL_P(op1));
11428
0
      break;
11429
2
    } else if (Z_TYPE_P(op1) == IS_OBJECT) {
11430
0
      zend_object *zobj = Z_OBJ_P(op1);
11431
11432
      /* first, we check if the handler is defined */
11433
0
      if (zobj->handlers->count_elements) {
11434
0
        if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
11435
0
          break;
11436
0
        }
11437
0
        if (UNEXPECTED(EG(exception))) {
11438
0
          count = 0;
11439
0
          break;
11440
0
        }
11441
0
      }
11442
11443
      /* if not and the object implements Countable we call its count() method */
11444
0
      if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
11445
0
        zval retval;
11446
11447
0
        zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
11448
0
        zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
11449
0
        count = zval_get_long(&retval);
11450
0
        zval_ptr_dtor(&retval);
11451
0
        break;
11452
0
      }
11453
11454
      /* If There's no handler and it doesn't implement Countable then emit a TypeError */
11455
2
    } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11456
0
      op1 = Z_REFVAL_P(op1);
11457
0
      continue;
11458
2
    } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11459
0
      ZVAL_UNDEFINED_OP1();
11460
0
    }
11461
2
    count = 0;
11462
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));
11463
2
    break;
11464
2
  }
11465
11466
2
  ZVAL_LONG(EX_VAR(opline->result.var), count);
11467
11468
2
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11469
2
}
11470
11471
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11472
0
{
11473
0
  USE_OPLINE
11474
11475
0
  if (IS_CONST == IS_UNUSED) {
11476
0
    SAVE_OPLINE();
11477
0
    if (UNEXPECTED(!EX(func)->common.scope)) {
11478
0
      zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
11479
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
11480
0
      HANDLE_EXCEPTION();
11481
0
    } else {
11482
0
      zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
11483
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
11484
0
      if (UNEXPECTED(EG(exception))) {
11485
0
        HANDLE_EXCEPTION();
11486
0
      }
11487
0
      ZEND_VM_NEXT_OPCODE();
11488
0
    }
11489
0
  } else {
11490
0
    zval *op1;
11491
11492
0
    SAVE_OPLINE();
11493
0
    op1 = RT_CONSTANT(opline, opline->op1);
11494
0
    while (1) {
11495
0
      if (Z_TYPE_P(op1) == IS_OBJECT) {
11496
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
11497
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11498
0
        op1 = Z_REFVAL_P(op1);
11499
0
        continue;
11500
0
      } else {
11501
0
        if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11502
0
          ZVAL_UNDEFINED_OP1();
11503
0
        }
11504
0
        zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
11505
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
11506
0
      }
11507
0
      break;
11508
0
    }
11509
11510
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11511
0
  }
11512
0
}
11513
11514
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11515
2
{
11516
2
  USE_OPLINE
11517
2
  zval *op1;
11518
2
  zend_string *type;
11519
11520
2
  SAVE_OPLINE();
11521
2
  op1 = RT_CONSTANT(opline, opline->op1);
11522
2
  type = zend_zval_get_legacy_type(op1);
11523
2
  if (EXPECTED(type)) {
11524
2
    ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
11525
2
  } else {
11526
0
    ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
11527
0
  }
11528
11529
2
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11530
2
}
11531
11532
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11533
18
{
11534
18
  USE_OPLINE
11535
18
  zend_array *ht;
11536
18
  uint32_t arg_count, result_size, skip;
11537
11538
18
  arg_count = EX_NUM_ARGS();
11539
18
  if (IS_CONST == IS_CONST) {
11540
18
    skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
11541
18
    if (arg_count < skip) {
11542
5
      result_size = 0;
11543
13
    } else {
11544
13
      result_size = arg_count - skip;
11545
13
    }
11546
18
  } else {
11547
0
    skip = 0;
11548
0
    result_size = arg_count;
11549
0
  }
11550
11551
18
  if (result_size) {
11552
13
    SAVE_OPLINE();
11553
13
    uint32_t first_extra_arg = EX(func)->op_array.num_args;
11554
11555
13
    ht = zend_new_array(result_size);
11556
13
    ZVAL_ARR(EX_VAR(opline->result.var), ht);
11557
13
    zend_hash_real_init_packed(ht);
11558
13
    ZEND_HASH_FILL_PACKED(ht) {
11559
13
      zval *p, *q;
11560
13
      uint32_t i = skip;
11561
13
      p = EX_VAR_NUM(i);
11562
13
      if (arg_count > first_extra_arg) {
11563
13
        while (i < first_extra_arg) {
11564
0
          q = p;
11565
0
          if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11566
0
            ZVAL_DEREF(q);
11567
0
            if (Z_OPT_REFCOUNTED_P(q)) {
11568
0
              Z_ADDREF_P(q);
11569
0
            }
11570
0
            ZEND_HASH_FILL_SET(q);
11571
0
          } else {
11572
0
            ZEND_HASH_FILL_SET_NULL();
11573
0
          }
11574
0
          ZEND_HASH_FILL_NEXT();
11575
0
          p++;
11576
0
          i++;
11577
0
        }
11578
13
        if (skip < first_extra_arg) {
11579
0
          skip = 0;
11580
13
        } else {
11581
13
          skip -= first_extra_arg;
11582
13
        }
11583
13
        p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
11584
13
      }
11585
39
      while (i < arg_count) {
11586
26
        q = p;
11587
26
        if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11588
26
          ZVAL_DEREF(q);
11589
26
          if (Z_OPT_REFCOUNTED_P(q)) {
11590
0
            Z_ADDREF_P(q);
11591
0
          }
11592
26
          ZEND_HASH_FILL_SET(q);
11593
26
        } else {
11594
0
          ZEND_HASH_FILL_SET_NULL();
11595
0
        }
11596
26
        ZEND_HASH_FILL_NEXT();
11597
26
        p++;
11598
26
        i++;
11599
26
      }
11600
13
    } ZEND_HASH_FILL_END();
11601
13
    ht->nNumOfElements = result_size;
11602
13
  } else {
11603
5
    ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
11604
5
  }
11605
18
  ZEND_VM_NEXT_OPCODE();
11606
18
}
11607
11608
/* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
11609
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11610
342
{
11611
342
  USE_OPLINE
11612
342
  SAVE_OPLINE();
11613
11614
342
  zend_class_entry *ce = EX(func)->common.scope;
11615
342
  ZEND_ASSERT(ce);
11616
11617
342
  zend_class_entry *parent_ce = ce->parent;
11618
342
  if (!parent_ce) {
11619
5
    zend_throw_error(NULL, "Cannot use \"parent\" when current class scope has no parent");
11620
5
    UNDEF_RESULT();
11621
5
    HANDLE_EXCEPTION();
11622
5
  }
11623
11624
337
  zend_string *property_name = Z_STR_P(RT_CONSTANT(opline, opline->op1));
11625
337
  zend_property_hook_kind hook_kind = opline->op2.num;
11626
11627
337
  zend_property_info *prop_info = zend_hash_find_ptr(&parent_ce->properties_info, property_name);
11628
337
  if (!prop_info) {
11629
7
    zend_throw_error(NULL, "Undefined property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name));
11630
7
    UNDEF_RESULT();
11631
7
    HANDLE_EXCEPTION();
11632
7
  }
11633
330
  if (prop_info->flags & ZEND_ACC_PRIVATE) {
11634
5
    zend_throw_error(NULL, "Cannot access private property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name));
11635
5
    UNDEF_RESULT();
11636
5
    HANDLE_EXCEPTION();
11637
5
  }
11638
11639
325
  zend_function **hooks = prop_info->hooks;
11640
325
  zend_function *hook = hooks ? hooks[hook_kind] : NULL;
11641
11642
325
  zend_execute_data *call;
11643
325
  if (hook) {
11644
65
    call = zend_vm_stack_push_call_frame(
11645
65
      ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS,
11646
65
      hook, opline->extended_value, Z_OBJ_P(ZEND_THIS));
11647
65
    if (EXPECTED(hook->type == ZEND_USER_FUNCTION)) {
11648
65
      if (UNEXPECTED(!RUN_TIME_CACHE(&hook->op_array))) {
11649
20
        init_func_run_time_cache(&hook->op_array);
11650
20
      }
11651
65
      call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
11652
65
    }
11653
260
  } else {
11654
260
    zend_function *fbc = zend_get_property_hook_trampoline(prop_info, hook_kind, property_name);
11655
260
    call = zend_vm_stack_push_call_frame(
11656
260
      ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS,
11657
260
      fbc, opline->extended_value, Z_OBJ_P(ZEND_THIS));
11658
260
  }
11659
11660
325
  call->prev_execute_data = EX(call);
11661
325
  EX(call) = call;
11662
325
  ZEND_VM_NEXT_OPCODE();
11663
325
}
11664
11665
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11666
45
{
11667
45
  USE_OPLINE
11668
45
  zval *op1, *op2;
11669
11670
45
  SAVE_OPLINE();
11671
45
  op1 = RT_CONSTANT(opline, opline->op1);
11672
45
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11673
45
  div_function(EX_VAR(opline->result.var), op1, op2);
11674
11675
11676
45
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11677
45
}
11678
11679
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11680
20
{
11681
20
  USE_OPLINE
11682
20
  zval *op1, *op2;
11683
11684
20
  SAVE_OPLINE();
11685
20
  op1 = RT_CONSTANT(opline, opline->op1);
11686
20
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11687
20
  pow_function(EX_VAR(opline->result.var), op1, op2);
11688
11689
11690
20
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11691
20
}
11692
11693
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11694
1.91k
{
11695
1.91k
  USE_OPLINE
11696
1.91k
  zval *op1, *op2;
11697
11698
1.91k
  op1 = RT_CONSTANT(opline, opline->op1);
11699
1.91k
  op2 = EX_VAR(opline->op2.var);
11700
11701
1.91k
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
11702
1.91k
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
11703
364
    zend_string *op1_str = Z_STR_P(op1);
11704
364
    zend_string *op2_str = Z_STR_P(op2);
11705
364
    zend_string *str;
11706
364
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
11707
11708
364
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11709
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
11710
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
11711
0
      } else {
11712
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11713
0
      }
11714
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11715
0
        zend_string_release_ex(op1_str, 0);
11716
0
      }
11717
364
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11718
1
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
11719
1
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
11720
1
      } else {
11721
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11722
0
      }
11723
1
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11724
0
        zend_string_release_ex(op2_str, 0);
11725
0
      }
11726
363
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
11727
363
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
11728
0
      size_t len = ZSTR_LEN(op1_str);
11729
11730
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
11731
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
11732
0
      }
11733
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
11734
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11735
0
      GC_ADD_FLAGS(str, flags);
11736
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11737
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11738
0
        zend_string_release_ex(op2_str, 0);
11739
0
      }
11740
363
    } else {
11741
363
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11742
363
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11743
363
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11744
363
      GC_ADD_FLAGS(str, flags);
11745
363
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11746
363
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11747
0
        zend_string_release_ex(op1_str, 0);
11748
0
      }
11749
363
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11750
0
        zend_string_release_ex(op2_str, 0);
11751
0
      }
11752
363
    }
11753
364
    ZEND_VM_NEXT_OPCODE();
11754
1.55k
  } else {
11755
1.55k
    SAVE_OPLINE();
11756
11757
1.55k
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11758
0
      op1 = ZVAL_UNDEFINED_OP1();
11759
0
    }
11760
1.55k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
11761
1.07k
      op2 = ZVAL_UNDEFINED_OP2();
11762
1.07k
    }
11763
1.55k
    concat_function(EX_VAR(opline->result.var), op1, op2);
11764
11765
11766
1.55k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11767
1.55k
  }
11768
1.91k
}
11769
11770
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11771
0
{
11772
0
  USE_OPLINE
11773
0
  zval *op1, *op2;
11774
11775
0
  SAVE_OPLINE();
11776
0
  op1 = RT_CONSTANT(opline, opline->op1);
11777
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11778
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
11779
11780
11781
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11782
0
}
11783
11784
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11785
343
{
11786
343
  USE_OPLINE
11787
343
  zval *container, *dim, *value;
11788
11789
343
  SAVE_OPLINE();
11790
343
  container = RT_CONSTANT(opline, opline->op1);
11791
343
  dim = EX_VAR(opline->op2.var);
11792
343
  if (IS_CONST != IS_CONST) {
11793
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11794
0
fetch_dim_r_array:
11795
0
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
11796
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
11797
0
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
11798
0
      container = Z_REFVAL_P(container);
11799
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11800
0
        goto fetch_dim_r_array;
11801
0
      } else {
11802
0
        goto fetch_dim_r_slow;
11803
0
      }
11804
0
    } else {
11805
0
fetch_dim_r_slow:
11806
0
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
11807
0
        dim++;
11808
0
      }
11809
0
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
11810
0
    }
11811
343
  } else {
11812
343
    zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
11813
343
  }
11814
11815
11816
343
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11817
343
}
11818
11819
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11820
0
{
11821
0
  USE_OPLINE
11822
0
  zval *container;
11823
11824
0
  SAVE_OPLINE();
11825
0
  container = RT_CONSTANT(opline, opline->op1);
11826
0
  zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
11827
11828
11829
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11830
0
}
11831
11832
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11833
0
{
11834
#if 0
11835
  USE_OPLINE
11836
#endif
11837
11838
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
11839
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
11840
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11841
0
    }
11842
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11843
0
  } else {
11844
0
    if (IS_CV == IS_UNUSED) {
11845
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11846
0
    }
11847
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11848
0
  }
11849
0
}
11850
11851
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11852
0
{
11853
0
  USE_OPLINE
11854
0
  zval *container;
11855
0
  void **cache_slot = NULL;
11856
11857
0
  SAVE_OPLINE();
11858
0
  container = RT_CONSTANT(opline, opline->op1);
11859
11860
0
  if (IS_CONST == IS_CONST ||
11861
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11862
0
    do {
11863
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11864
0
        container = Z_REFVAL_P(container);
11865
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11866
0
          break;
11867
0
        }
11868
0
      }
11869
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
11870
0
        ZVAL_UNDEFINED_OP1();
11871
0
      }
11872
0
      zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11873
0
      ZVAL_NULL(EX_VAR(opline->result.var));
11874
0
      goto fetch_obj_r_finish;
11875
0
    } while (0);
11876
0
  }
11877
11878
  /* here we are sure we are dealing with an object */
11879
0
  do {
11880
0
    zend_object *zobj = Z_OBJ_P(container);
11881
0
    zend_string *name, *tmp_name;
11882
0
    zval *retval;
11883
11884
0
    if (IS_CV == IS_CONST) {
11885
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
11886
11887
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11888
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11889
11890
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11891
0
fetch_obj_r_simple:
11892
0
          retval = OBJ_PROP(zobj, prop_offset);
11893
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
11894
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11895
0
              goto fetch_obj_r_copy;
11896
0
            } else {
11897
0
fetch_obj_r_fast_copy:
11898
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11899
0
              ZEND_VM_NEXT_OPCODE();
11900
0
            }
11901
0
          }
11902
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
11903
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
11904
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
11905
0
            prop_offset = prop_info->offset;
11906
0
            goto fetch_obj_r_simple;
11907
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
11908
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
11909
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
11910
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
11911
11912
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
11913
0
            if (IS_CONST & IS_CV) {
11914
0
              GC_ADDREF(zobj);
11915
0
            }
11916
0
            if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
11917
0
              call_info |= ZEND_CALL_RELEASE_THIS;
11918
0
            }
11919
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
11920
0
            call->prev_execute_data = execute_data;
11921
0
            call->call = NULL;
11922
0
            call->return_value = EX_VAR(opline->result.var);
11923
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
11924
11925
0
            execute_data = call;
11926
0
            EG(current_execute_data) = execute_data;
11927
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
11928
11929
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
11930
            opline = hook->op_array.opcodes;
11931
#else
11932
0
            EX(opline) = hook->op_array.opcodes;
11933
0
#endif
11934
0
            LOAD_OPLINE_EX();
11935
11936
11937
0
            ZEND_VM_ENTER_EX();
11938
0
          }
11939
          /* Fall through to read_property for hooks. */
11940
0
        } else if (EXPECTED(zobj->properties != NULL)) {
11941
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
11942
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11943
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11944
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11945
11946
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11947
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11948
11949
0
              if (EXPECTED(p->key == name) ||
11950
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
11951
0
                   EXPECTED(p->key != NULL) &&
11952
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
11953
0
                retval = &p->val;
11954
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11955
0
                  goto fetch_obj_r_copy;
11956
0
                } else {
11957
0
                  goto fetch_obj_r_fast_copy;
11958
0
                }
11959
0
              }
11960
0
            }
11961
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11962
0
          }
11963
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
11964
0
          if (EXPECTED(retval)) {
11965
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11966
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11967
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11968
0
              goto fetch_obj_r_copy;
11969
0
            } else {
11970
0
              goto fetch_obj_r_fast_copy;
11971
0
            }
11972
0
          }
11973
0
        }
11974
0
      }
11975
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11976
0
    } else {
11977
0
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11978
0
      if (UNEXPECTED(!name)) {
11979
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
11980
0
        break;
11981
0
      }
11982
0
    }
11983
11984
0
#if ZEND_DEBUG
11985
    /* For non-standard object handlers, verify a declared property type in debug builds.
11986
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
11987
0
    zend_property_info *prop_info = NULL;
11988
0
    if (zobj->handlers->read_property != zend_std_read_property) {
11989
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
11990
0
    }
11991
0
#endif
11992
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
11993
0
#if ZEND_DEBUG
11994
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
11995
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
11996
0
      ZVAL_OPT_DEREF(retval);
11997
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
11998
0
    }
11999
0
#endif
12000
12001
0
    if (IS_CV != IS_CONST) {
12002
0
      zend_tmp_string_release(tmp_name);
12003
0
    }
12004
12005
0
    if (retval != EX_VAR(opline->result.var)) {
12006
0
fetch_obj_r_copy:
12007
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
12008
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
12009
0
      zend_unwrap_reference(retval);
12010
0
    }
12011
0
  } while (0);
12012
12013
0
fetch_obj_r_finish:
12014
12015
12016
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12017
0
}
12018
12019
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12020
0
{
12021
0
  USE_OPLINE
12022
0
  zval *container;
12023
0
  void **cache_slot = NULL;
12024
12025
0
  SAVE_OPLINE();
12026
0
  container = RT_CONSTANT(opline, opline->op1);
12027
12028
0
  if (IS_CONST == IS_CONST ||
12029
0
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
12030
0
    do {
12031
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
12032
0
        container = Z_REFVAL_P(container);
12033
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
12034
0
          break;
12035
0
        }
12036
0
      }
12037
0
      if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
12038
0
        ZVAL_UNDEFINED_OP2();
12039
0
      }
12040
0
      ZVAL_NULL(EX_VAR(opline->result.var));
12041
0
      goto fetch_obj_is_finish;
12042
0
    } while (0);
12043
0
  }
12044
12045
  /* here we are sure we are dealing with an object */
12046
0
  do {
12047
0
    zend_object *zobj = Z_OBJ_P(container);
12048
0
    zend_string *name, *tmp_name;
12049
0
    zval *retval;
12050
12051
0
    if (IS_CV == IS_CONST) {
12052
0
      cache_slot = CACHE_ADDR(opline->extended_value);
12053
12054
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
12055
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
12056
12057
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
12058
0
fetch_obj_is_simple:
12059
0
          retval = OBJ_PROP(zobj, prop_offset);
12060
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
12061
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
12062
0
              goto fetch_obj_is_copy;
12063
0
            } else {
12064
0
fetch_obj_is_fast_copy:
12065
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
12066
0
              ZEND_VM_NEXT_OPCODE();
12067
0
            }
12068
0
          }
12069
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
12070
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
12071
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
12072
0
            prop_offset = prop_info->offset;
12073
0
            goto fetch_obj_is_simple;
12074
0
          }
12075
          /* Fall through to read_property for hooks. */
12076
0
        } else if (EXPECTED(zobj->properties != NULL)) {
12077
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
12078
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
12079
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
12080
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
12081
12082
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
12083
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
12084
12085
0
              if (EXPECTED(p->key == name) ||
12086
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
12087
0
                   EXPECTED(p->key != NULL) &&
12088
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
12089
0
                retval = &p->val;
12090
0
                if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
12091
0
                  goto fetch_obj_is_copy;
12092
0
                } else {
12093
0
                  goto fetch_obj_is_fast_copy;
12094
0
                }
12095
0
              }
12096
0
            }
12097
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
12098
0
          }
12099
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
12100
0
          if (EXPECTED(retval)) {
12101
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
12102
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
12103
0
            if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
12104
0
              goto fetch_obj_is_copy;
12105
0
            } else {
12106
0
              goto fetch_obj_is_fast_copy;
12107
0
            }
12108
0
          }
12109
0
        }
12110
0
      }
12111
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
12112
0
    } else {
12113
0
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
12114
0
      if (UNEXPECTED(!name)) {
12115
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
12116
0
        break;
12117
0
      }
12118
0
    }
12119
12120
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
12121
12122
0
    if (IS_CV != IS_CONST) {
12123
0
      zend_tmp_string_release(tmp_name);
12124
0
    }
12125
12126
0
    if (retval != EX_VAR(opline->result.var)) {
12127
0
fetch_obj_is_copy:
12128
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
12129
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
12130
0
      zend_unwrap_reference(retval);
12131
0
    }
12132
0
  } while (0);
12133
12134
0
fetch_obj_is_finish:
12135
12136
12137
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12138
0
}
12139
12140
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12141
0
{
12142
#if 0
12143
  USE_OPLINE
12144
#endif
12145
12146
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
12147
    /* Behave like FETCH_OBJ_W */
12148
0
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
12149
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12150
0
    }
12151
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12152
0
  } else {
12153
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12154
0
  }
12155
0
}
12156
12157
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12158
15
{
12159
15
  USE_OPLINE
12160
15
  zval *container;
12161
12162
15
  SAVE_OPLINE();
12163
15
  container = RT_CONSTANT(opline, opline->op1);
12164
15
  zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
12165
12166
15
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12167
15
}
12168
12169
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12170
5.34k
{
12171
5.34k
  USE_OPLINE
12172
5.34k
  zval *op1, *op2;
12173
5.34k
  zend_string *op1_str, *op2_str, *str;
12174
12175
12176
5.34k
  op1 = RT_CONSTANT(opline, opline->op1);
12177
5.34k
  op2 = EX_VAR(opline->op2.var);
12178
5.34k
  if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
12179
5.34k
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
12180
536
    zend_string *op1_str = Z_STR_P(op1);
12181
536
    zend_string *op2_str = Z_STR_P(op2);
12182
536
    zend_string *str;
12183
536
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
12184
12185
536
    if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
12186
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
12187
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
12188
0
      } else {
12189
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
12190
0
      }
12191
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
12192
0
        zend_string_release_ex(op1_str, 0);
12193
0
      }
12194
536
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
12195
12
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
12196
12
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
12197
12
      } else {
12198
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
12199
0
      }
12200
12
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12201
0
        zend_string_release_ex(op2_str, 0);
12202
0
      }
12203
524
    } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
12204
524
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
12205
0
      size_t len = ZSTR_LEN(op1_str);
12206
12207
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
12208
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12209
0
      GC_ADD_FLAGS(str, flags);
12210
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12211
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12212
0
        zend_string_release_ex(op2_str, 0);
12213
0
      }
12214
524
    } else {
12215
524
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
12216
524
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
12217
524
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12218
524
      GC_ADD_FLAGS(str, flags);
12219
524
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12220
524
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
12221
0
        zend_string_release_ex(op1_str, 0);
12222
0
      }
12223
524
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12224
0
        zend_string_release_ex(op2_str, 0);
12225
0
      }
12226
524
    }
12227
536
    ZEND_VM_NEXT_OPCODE();
12228
536
  }
12229
12230
5.34k
  SAVE_OPLINE();
12231
4.80k
  if (IS_CONST == IS_CONST) {
12232
4.80k
    op1_str = Z_STR_P(op1);
12233
4.80k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
12234
0
    op1_str = zend_string_copy(Z_STR_P(op1));
12235
0
  } else {
12236
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
12237
0
      ZVAL_UNDEFINED_OP1();
12238
0
    }
12239
0
    op1_str = zval_get_string_func(op1);
12240
0
  }
12241
4.80k
  if (IS_CV == IS_CONST) {
12242
0
    op2_str = Z_STR_P(op2);
12243
4.80k
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
12244
0
    op2_str = zend_string_copy(Z_STR_P(op2));
12245
4.80k
  } else {
12246
4.80k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
12247
2.73k
      ZVAL_UNDEFINED_OP2();
12248
2.73k
    }
12249
4.80k
    op2_str = zval_get_string_func(op2);
12250
4.80k
  }
12251
4.80k
  do {
12252
4.80k
    if (IS_CONST != IS_CONST) {
12253
0
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
12254
0
        if (IS_CV == IS_CONST) {
12255
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
12256
0
            GC_ADDREF(op2_str);
12257
0
          }
12258
0
        }
12259
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
12260
0
        zend_string_release_ex(op1_str, 0);
12261
0
        break;
12262
0
      }
12263
0
    }
12264
4.80k
    if (IS_CV != IS_CONST) {
12265
4.80k
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
12266
2.74k
        if (IS_CONST == IS_CONST) {
12267
2.74k
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
12268
0
            GC_ADDREF(op1_str);
12269
0
          }
12270
2.74k
        }
12271
2.74k
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
12272
2.74k
        zend_string_release_ex(op2_str, 0);
12273
2.74k
        break;
12274
2.74k
      }
12275
4.80k
    }
12276
2.06k
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
12277
2.06k
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
12278
2.06k
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12279
12280
2.06k
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
12281
2.06k
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12282
2.06k
    if (IS_CONST != IS_CONST) {
12283
0
      zend_string_release_ex(op1_str, 0);
12284
0
    }
12285
2.06k
    if (IS_CV != IS_CONST) {
12286
2.06k
      zend_string_release_ex(op2_str, 0);
12287
2.06k
    }
12288
2.06k
  } while (0);
12289
12290
12291
4.80k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12292
4.80k
}
12293
12294
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12295
0
{
12296
0
  USE_OPLINE
12297
0
  zval *function_name;
12298
0
  zval *object;
12299
0
  zend_function *fbc;
12300
0
  zend_class_entry *called_scope;
12301
0
  zend_object *obj;
12302
0
  zend_execute_data *call;
12303
0
  uint32_t call_info;
12304
12305
0
  SAVE_OPLINE();
12306
12307
0
  object = RT_CONSTANT(opline, opline->op1);
12308
12309
0
  if (IS_CV != IS_CONST) {
12310
0
    function_name = EX_VAR(opline->op2.var);
12311
0
  }
12312
12313
0
  if (IS_CV != IS_CONST &&
12314
0
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12315
0
    do {
12316
0
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
12317
0
        function_name = Z_REFVAL_P(function_name);
12318
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12319
0
          break;
12320
0
        }
12321
0
      } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12322
0
        ZVAL_UNDEFINED_OP2();
12323
0
        if (UNEXPECTED(EG(exception) != NULL)) {
12324
12325
0
          HANDLE_EXCEPTION();
12326
0
        }
12327
0
      }
12328
0
      zend_throw_error(NULL, "Method name must be a string");
12329
12330
12331
0
      HANDLE_EXCEPTION();
12332
0
    } while (0);
12333
0
  }
12334
12335
0
  if (IS_CONST == IS_UNUSED) {
12336
0
    obj = Z_OBJ_P(object);
12337
0
  } else {
12338
0
    do {
12339
0
      if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
12340
0
        obj = Z_OBJ_P(object);
12341
0
      } else {
12342
0
        if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
12343
0
          zend_reference *ref = Z_REF_P(object);
12344
12345
0
          object = &ref->val;
12346
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
12347
0
            obj = Z_OBJ_P(object);
12348
0
            if (IS_CONST & IS_VAR) {
12349
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12350
0
                efree_size(ref, sizeof(zend_reference));
12351
0
              } else {
12352
0
                Z_ADDREF_P(object);
12353
0
              }
12354
0
            }
12355
0
            break;
12356
0
          }
12357
0
        }
12358
0
        if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
12359
0
          object = ZVAL_UNDEFINED_OP1();
12360
0
          if (UNEXPECTED(EG(exception) != NULL)) {
12361
0
            if (IS_CV != IS_CONST) {
12362
12363
0
            }
12364
0
            HANDLE_EXCEPTION();
12365
0
          }
12366
0
        }
12367
0
        if (IS_CV == IS_CONST) {
12368
0
          function_name = EX_VAR(opline->op2.var);
12369
0
        }
12370
0
        zend_invalid_method_call(object, function_name);
12371
12372
12373
0
        HANDLE_EXCEPTION();
12374
0
      }
12375
0
    } while (0);
12376
0
  }
12377
12378
0
  called_scope = obj->ce;
12379
12380
0
  if (IS_CV == IS_CONST &&
12381
0
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
12382
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12383
0
  } else {
12384
0
    zend_object *orig_obj = obj;
12385
12386
0
    if (IS_CV == IS_CONST) {
12387
0
      function_name = EX_VAR(opline->op2.var);
12388
0
    }
12389
12390
    /* First, locate the function. */
12391
0
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12392
0
    if (UNEXPECTED(fbc == NULL)) {
12393
0
      if (EXPECTED(!EG(exception))) {
12394
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
12395
0
      }
12396
12397
0
      if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
12398
0
        zend_objects_store_del(orig_obj);
12399
0
      }
12400
0
      HANDLE_EXCEPTION();
12401
0
    }
12402
0
    if (IS_CV == IS_CONST &&
12403
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12404
0
        EXPECTED(obj == orig_obj)) {
12405
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
12406
0
    }
12407
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
12408
0
      GC_ADDREF(obj); /* For $this pointer */
12409
0
      if (GC_DELREF(orig_obj) == 0) {
12410
0
        zend_objects_store_del(orig_obj);
12411
0
      }
12412
0
    }
12413
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12414
0
      init_func_run_time_cache(&fbc->op_array);
12415
0
    }
12416
0
  }
12417
12418
0
  if (IS_CV != IS_CONST) {
12419
12420
0
  }
12421
12422
0
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12423
0
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
12424
0
    if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
12425
0
      zend_objects_store_del(obj);
12426
0
      if (UNEXPECTED(EG(exception))) {
12427
0
        HANDLE_EXCEPTION();
12428
0
      }
12429
0
    }
12430
    /* call static method */
12431
0
    obj = (zend_object*)called_scope;
12432
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
12433
0
  } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
12434
0
    if (IS_CONST == IS_CV) {
12435
0
      GC_ADDREF(obj); /* For $this pointer */
12436
0
    }
12437
    /* CV may be changed indirectly (e.g. when it's a reference) */
12438
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
12439
0
  }
12440
12441
0
  call = zend_vm_stack_push_call_frame(call_info,
12442
0
    fbc, opline->extended_value, obj);
12443
0
  call->prev_execute_data = EX(call);
12444
0
  EX(call) = call;
12445
12446
0
  ZEND_VM_NEXT_OPCODE();
12447
0
}
12448
12449
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12450
54
{
12451
54
  USE_OPLINE
12452
54
  zval *function_name;
12453
54
  zend_class_entry *ce;
12454
54
  uint32_t call_info;
12455
54
  zend_function *fbc;
12456
54
  zend_execute_data *call;
12457
12458
54
  SAVE_OPLINE();
12459
12460
54
  if (IS_CONST == IS_CONST) {
12461
    /* no function found. try a static method in class */
12462
54
    ce = CACHED_PTR(opline->result.num);
12463
54
    if (UNEXPECTED(ce == NULL)) {
12464
44
      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);
12465
44
      if (UNEXPECTED(ce == NULL)) {
12466
12467
4
        HANDLE_EXCEPTION();
12468
4
      }
12469
40
      if (IS_CV != IS_CONST) {
12470
40
        CACHE_PTR(opline->result.num, ce);
12471
40
      }
12472
40
    }
12473
54
  } else if (IS_CONST == IS_UNUSED) {
12474
0
    ce = zend_fetch_class(NULL, opline->op1.num);
12475
0
    if (UNEXPECTED(ce == NULL)) {
12476
12477
0
      HANDLE_EXCEPTION();
12478
0
    }
12479
0
  } else {
12480
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
12481
0
  }
12482
12483
50
  if (IS_CONST == IS_CONST &&
12484
50
      IS_CV == IS_CONST &&
12485
50
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
12486
    /* nothing to do */
12487
50
  } else if (IS_CONST != IS_CONST &&
12488
50
             IS_CV == IS_CONST &&
12489
50
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
12490
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12491
50
  } else if (IS_CV != IS_UNUSED) {
12492
50
    function_name = EX_VAR(opline->op2.var);
12493
50
    if (IS_CV != IS_CONST) {
12494
50
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12495
8
        do {
12496
8
          if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
12497
0
            function_name = Z_REFVAL_P(function_name);
12498
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12499
0
              break;
12500
0
            }
12501
8
          } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12502
3
            ZVAL_UNDEFINED_OP2();
12503
3
            if (UNEXPECTED(EG(exception) != NULL)) {
12504
0
              HANDLE_EXCEPTION();
12505
0
            }
12506
3
          }
12507
8
          zend_throw_error(NULL, "Method name must be a string");
12508
12509
8
          HANDLE_EXCEPTION();
12510
8
        } while (0);
12511
8
      }
12512
50
    }
12513
12514
42
    if (ce->get_static_method) {
12515
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
12516
42
    } else {
12517
42
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12518
42
    }
12519
42
    if (UNEXPECTED(fbc == NULL)) {
12520
4
      if (EXPECTED(!EG(exception))) {
12521
4
        zend_undefined_method(ce, Z_STR_P(function_name));
12522
4
      }
12523
12524
4
      HANDLE_EXCEPTION();
12525
4
    }
12526
38
    if (IS_CV == IS_CONST &&
12527
38
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12528
38
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
12529
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
12530
0
    }
12531
38
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12532
5
      init_func_run_time_cache(&fbc->op_array);
12533
5
    }
12534
38
    if (IS_CV != IS_CONST) {
12535
12536
38
    }
12537
38
  } else {
12538
0
    if (UNEXPECTED(ce->constructor == NULL)) {
12539
0
      zend_throw_error(NULL, "Cannot call constructor");
12540
0
      HANDLE_EXCEPTION();
12541
0
    }
12542
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)) {
12543
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
12544
0
      HANDLE_EXCEPTION();
12545
0
    }
12546
0
    fbc = ce->constructor;
12547
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12548
0
      init_func_run_time_cache(&fbc->op_array);
12549
0
    }
12550
0
  }
12551
12552
38
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
12553
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
12554
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
12555
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12556
0
    } else {
12557
0
      zend_non_static_method_call(fbc);
12558
0
      HANDLE_EXCEPTION();
12559
0
    }
12560
38
  } else {
12561
    /* previous opcode is ZEND_FETCH_CLASS */
12562
38
    if (IS_CONST == IS_UNUSED
12563
38
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
12564
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
12565
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
12566
0
        ce = Z_OBJCE(EX(This));
12567
0
      } else {
12568
0
        ce = Z_CE(EX(This));
12569
0
      }
12570
0
    }
12571
38
    call_info = ZEND_CALL_NESTED_FUNCTION;
12572
38
  }
12573
12574
38
  call = zend_vm_stack_push_call_frame(call_info,
12575
38
    fbc, opline->extended_value, ce);
12576
38
  call->prev_execute_data = EX(call);
12577
38
  EX(call) = call;
12578
12579
38
  ZEND_VM_NEXT_OPCODE();
12580
38
}
12581
12582
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12583
492
{
12584
492
  USE_OPLINE
12585
492
  zval *function_name;
12586
492
  zend_fcall_info_cache fcc;
12587
492
  char *error = NULL;
12588
492
  zend_function *func;
12589
492
  void *object_or_called_scope;
12590
492
  zend_execute_data *call;
12591
492
  uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
12592
12593
492
  SAVE_OPLINE();
12594
492
  function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12595
492
  if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
12596
485
    ZEND_ASSERT(!error);
12597
12598
    /* Deprecation can be emitted from zend_is_callable_ex(), which can
12599
     * invoke a user error handler and throw an exception.
12600
     * For the CONST and CV case we reuse the same exception block below
12601
     * to make sure we don't increase VM size too much. */
12602
485
    if (!(IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12603
12604
0
      HANDLE_EXCEPTION();
12605
0
    }
12606
12607
485
    func = fcc.function_handler;
12608
485
    object_or_called_scope = fcc.called_scope;
12609
485
    if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
12610
      /* Delay closure destruction until its invocation */
12611
100
      GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
12612
100
      call_info |= ZEND_CALL_CLOSURE;
12613
100
      if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
12614
2
        call_info |= ZEND_CALL_FAKE_CLOSURE;
12615
2
      }
12616
100
      if (fcc.object) {
12617
2
        object_or_called_scope = fcc.object;
12618
2
        call_info |= ZEND_CALL_HAS_THIS;
12619
2
      }
12620
385
    } else if (fcc.object) {
12621
344
      GC_ADDREF(fcc.object); /* For $this pointer */
12622
344
      object_or_called_scope = fcc.object;
12623
344
      call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
12624
344
    }
12625
12626
485
    if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12627
0
      if (call_info & ZEND_CALL_CLOSURE) {
12628
0
        zend_object_release(ZEND_CLOSURE_OBJECT(func));
12629
0
      } else if (call_info & ZEND_CALL_RELEASE_THIS) {
12630
0
        zend_object_release(fcc.object);
12631
0
      }
12632
0
      HANDLE_EXCEPTION();
12633
0
    }
12634
12635
485
    if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
12636
11
      init_func_run_time_cache(&func->op_array);
12637
11
    }
12638
485
  } else {
12639
7
    zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
12640
7
    efree(error);
12641
12642
7
    HANDLE_EXCEPTION();
12643
7
  }
12644
12645
485
  call = zend_vm_stack_push_call_frame(call_info,
12646
485
    func, opline->extended_value, object_or_called_scope);
12647
485
  call->prev_execute_data = EX(call);
12648
485
  EX(call) = call;
12649
12650
485
  ZEND_VM_NEXT_OPCODE();
12651
485
}
12652
12653
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12654
403
{
12655
403
  USE_OPLINE
12656
403
  zval *expr_ptr, new_expr;
12657
12658
403
  SAVE_OPLINE();
12659
403
  if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
12660
403
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
12661
0
    expr_ptr = zend_get_bad_ptr();
12662
0
    if (Z_ISREF_P(expr_ptr)) {
12663
0
      Z_ADDREF_P(expr_ptr);
12664
0
    } else {
12665
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
12666
0
    }
12667
12668
403
  } else {
12669
403
    expr_ptr = RT_CONSTANT(opline, opline->op1);
12670
403
    if (IS_CONST == IS_TMP_VAR) {
12671
      /* pass */
12672
403
    } else if (IS_CONST == IS_CONST) {
12673
403
      Z_TRY_ADDREF_P(expr_ptr);
12674
403
    } else if (IS_CONST == IS_CV) {
12675
0
      ZVAL_DEREF(expr_ptr);
12676
0
      Z_TRY_ADDREF_P(expr_ptr);
12677
0
    } else /* if (IS_CONST == IS_VAR) */ {
12678
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
12679
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
12680
12681
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
12682
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12683
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
12684
0
          expr_ptr = &new_expr;
12685
0
          efree_size(ref, sizeof(zend_reference));
12686
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
12687
0
          Z_ADDREF_P(expr_ptr);
12688
0
        }
12689
0
      }
12690
0
    }
12691
403
  }
12692
12693
403
  if (IS_CV != IS_UNUSED) {
12694
403
    zval *offset = EX_VAR(opline->op2.var);
12695
403
    zend_string *str;
12696
403
    zend_ulong hval;
12697
12698
403
add_again:
12699
403
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12700
13
      str = Z_STR_P(offset);
12701
13
      if (IS_CV != IS_CONST) {
12702
13
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
12703
0
          goto num_index;
12704
0
        }
12705
13
      }
12706
39
str_index:
12707
39
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
12708
390
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12709
332
      hval = Z_LVAL_P(offset);
12710
364
num_index:
12711
364
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
12712
364
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
12713
0
      offset = Z_REFVAL_P(offset);
12714
0
      goto add_again;
12715
58
    } else if (Z_TYPE_P(offset) == IS_NULL) {
12716
2
      str = ZSTR_EMPTY_ALLOC();
12717
2
      goto str_index;
12718
56
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
12719
30
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
12720
30
      goto num_index;
12721
30
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
12722
2
      hval = 0;
12723
2
      goto num_index;
12724
24
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
12725
0
      hval = 1;
12726
0
      goto num_index;
12727
24
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
12728
0
      zend_use_resource_as_offset(offset);
12729
0
      hval = Z_RES_HANDLE_P(offset);
12730
0
      goto num_index;
12731
24
    } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
12732
24
      ZVAL_UNDEFINED_OP2();
12733
24
      str = ZSTR_EMPTY_ALLOC();
12734
24
      goto str_index;
12735
24
    } else {
12736
0
      zend_illegal_array_offset_access(offset);
12737
0
      zval_ptr_dtor_nogc(expr_ptr);
12738
0
    }
12739
12740
403
  } else {
12741
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
12742
0
      zend_cannot_add_element();
12743
0
      zval_ptr_dtor_nogc(expr_ptr);
12744
0
    }
12745
0
  }
12746
403
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12747
403
}
12748
12749
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12750
362
{
12751
362
  zval *array;
12752
362
  uint32_t size;
12753
362
  USE_OPLINE
12754
12755
362
  SAVE_OPLINE();
12756
362
  array = EX_VAR(opline->result.var);
12757
362
  if (IS_CONST != IS_UNUSED) {
12758
362
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
12759
362
    ZVAL_ARR(array, zend_new_array(size));
12760
    /* Explicitly initialize array as not-packed if flag is set */
12761
362
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
12762
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
12763
0
    }
12764
362
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12765
362
  } else {
12766
0
    ZVAL_ARR(array, zend_new_array(0));
12767
0
    ZEND_VM_NEXT_OPCODE();
12768
0
  }
12769
362
}
12770
12771
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12772
172
{
12773
172
  USE_OPLINE
12774
172
  zval *container;
12775
172
  bool result;
12776
172
  zend_ulong hval;
12777
172
  zval *offset;
12778
12779
172
  SAVE_OPLINE();
12780
172
  container = RT_CONSTANT(opline, opline->op1);
12781
172
  offset = EX_VAR(opline->op2.var);
12782
12783
172
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12784
168
    HashTable *ht;
12785
168
    zval *value;
12786
168
    zend_string *str;
12787
12788
168
isset_dim_obj_array:
12789
168
    ht = Z_ARRVAL_P(container);
12790
168
isset_again:
12791
168
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12792
0
      str = Z_STR_P(offset);
12793
0
      if (IS_CV != IS_CONST) {
12794
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
12795
0
          goto num_index_prop;
12796
0
        }
12797
0
      }
12798
0
      value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
12799
168
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12800
168
      hval = Z_LVAL_P(offset);
12801
168
num_index_prop:
12802
168
      value = zend_hash_index_find(ht, hval);
12803
168
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
12804
0
      offset = Z_REFVAL_P(offset);
12805
0
      goto isset_again;
12806
0
    } else {
12807
0
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
12808
0
      if (UNEXPECTED(EG(exception))) {
12809
0
        result = 0;
12810
0
        goto isset_dim_obj_exit;
12811
0
      }
12812
0
    }
12813
12814
168
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
12815
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
12816
168
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
12817
168
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
12818
12819
168
      if (IS_CONST & (IS_CONST|IS_CV)) {
12820
        /* avoid exception check */
12821
12822
168
        ZEND_VM_SMART_BRANCH(result, 0);
12823
168
      }
12824
168
    } else {
12825
0
      result = (value == NULL || !i_zend_is_true(value));
12826
0
    }
12827
0
    goto isset_dim_obj_exit;
12828
168
  } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
12829
0
    container = Z_REFVAL_P(container);
12830
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12831
0
      goto isset_dim_obj_array;
12832
0
    }
12833
0
  }
12834
12835
4
  if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
12836
0
    offset++;
12837
0
  }
12838
4
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
12839
4
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
12840
4
  } else {
12841
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
12842
0
  }
12843
12844
4
isset_dim_obj_exit:
12845
12846
12847
4
  ZEND_VM_SMART_BRANCH(result, 1);
12848
4
}
12849
12850
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12851
2
{
12852
2
  USE_OPLINE
12853
2
  zval *container;
12854
2
  int result;
12855
2
  zval *offset;
12856
2
  zend_string *name, *tmp_name;
12857
12858
2
  SAVE_OPLINE();
12859
2
  container = RT_CONSTANT(opline, opline->op1);
12860
2
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12861
12862
2
  if (IS_CONST == IS_CONST ||
12863
2
      (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
12864
2
    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
12865
0
      container = Z_REFVAL_P(container);
12866
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
12867
0
        result = (opline->extended_value & ZEND_ISEMPTY);
12868
0
        goto isset_object_finish;
12869
0
      }
12870
2
    } else {
12871
2
      result = (opline->extended_value & ZEND_ISEMPTY);
12872
2
      goto isset_object_finish;
12873
2
    }
12874
2
  }
12875
12876
0
  if (IS_CV == IS_CONST) {
12877
0
    name = Z_STR_P(offset);
12878
0
  } else {
12879
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
12880
0
    if (UNEXPECTED(!name)) {
12881
0
      result = 0;
12882
0
      goto isset_object_finish;
12883
0
    }
12884
0
  }
12885
12886
0
  result =
12887
0
    (opline->extended_value & ZEND_ISEMPTY) ^
12888
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));
12889
12890
0
  if (IS_CV != IS_CONST) {
12891
0
    zend_tmp_string_release(tmp_name);
12892
0
  }
12893
12894
2
isset_object_finish:
12895
12896
12897
2
  ZEND_VM_SMART_BRANCH(result, 1);
12898
2
}
12899
12900
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12901
14
{
12902
14
  USE_OPLINE
12903
12904
14
  zval *key, *subject;
12905
14
  HashTable *ht;
12906
14
  bool result;
12907
12908
14
  SAVE_OPLINE();
12909
12910
14
  key = RT_CONSTANT(opline, opline->op1);
12911
14
  subject = EX_VAR(opline->op2.var);
12912
12913
14
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12914
12
array_key_exists_array:
12915
12
    ht = Z_ARRVAL_P(subject);
12916
12
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
12917
12
  } else {
12918
2
    if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
12919
0
      subject = Z_REFVAL_P(subject);
12920
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12921
0
        goto array_key_exists_array;
12922
0
      }
12923
0
    }
12924
2
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
12925
2
    result = 0;
12926
2
  }
12927
12928
12929
14
  ZEND_VM_SMART_BRANCH(result, 1);
12930
14
}
12931
12932
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12933
32
{
12934
32
  USE_OPLINE
12935
12936
32
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
12937
12938
32
  SAVE_OPLINE();
12939
32
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
12940
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12941
0
  }
12942
12943
  /* Destroy the previously yielded value */
12944
32
  zval_ptr_dtor(&generator->value);
12945
12946
  /* Destroy the previously yielded key */
12947
32
  zval_ptr_dtor(&generator->key);
12948
12949
  /* Set the new yielded value */
12950
32
  if (IS_CONST != IS_UNUSED) {
12951
32
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
12952
      /* Constants and temporary variables aren't yieldable by reference,
12953
       * but we still allow them with a notice. */
12954
0
      if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
12955
0
        zval *value;
12956
12957
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12958
12959
0
        value = RT_CONSTANT(opline, opline->op1);
12960
0
        ZVAL_COPY_VALUE(&generator->value, value);
12961
0
        if (IS_CONST == IS_CONST) {
12962
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12963
0
            Z_ADDREF(generator->value);
12964
0
          }
12965
0
        }
12966
0
      } else {
12967
0
        zval *value_ptr = zend_get_bad_ptr();
12968
12969
        /* If a function call result is yielded and the function did
12970
         * not return by reference we throw a notice. */
12971
0
        do {
12972
0
          if (IS_CONST == IS_VAR) {
12973
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
12974
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
12975
0
             && !Z_ISREF_P(value_ptr)) {
12976
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12977
0
              ZVAL_COPY(&generator->value, value_ptr);
12978
0
              break;
12979
0
            }
12980
0
          }
12981
0
          if (Z_ISREF_P(value_ptr)) {
12982
0
            Z_ADDREF_P(value_ptr);
12983
0
          } else {
12984
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
12985
0
          }
12986
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
12987
0
        } while (0);
12988
12989
0
      }
12990
32
    } else {
12991
32
      zval *value = RT_CONSTANT(opline, opline->op1);
12992
12993
      /* Consts, temporary variables and references need copying */
12994
32
      if (IS_CONST == IS_CONST) {
12995
32
        ZVAL_COPY_VALUE(&generator->value, value);
12996
32
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12997
0
          Z_ADDREF(generator->value);
12998
0
        }
12999
32
      } else if (IS_CONST == IS_TMP_VAR) {
13000
0
        ZVAL_COPY_VALUE(&generator->value, value);
13001
0
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
13002
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
13003
13004
0
      } else {
13005
0
        ZVAL_COPY_VALUE(&generator->value, value);
13006
0
        if (IS_CONST == IS_CV) {
13007
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
13008
0
        }
13009
0
      }
13010
32
    }
13011
32
  } else {
13012
    /* If no value was specified yield null */
13013
0
    ZVAL_NULL(&generator->value);
13014
0
  }
13015
13016
  /* Set the new yielded key */
13017
32
  if (IS_CV != IS_UNUSED) {
13018
32
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
13019
32
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
13020
0
      key = Z_REFVAL_P(key);
13021
0
    }
13022
32
    ZVAL_COPY(&generator->key, key);
13023
13024
32
    if (Z_TYPE(generator->key) == IS_LONG
13025
32
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
13026
32
    ) {
13027
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
13028
0
    }
13029
32
  } else {
13030
    /* If no key was specified we use auto-increment keys */
13031
0
    generator->largest_used_integer_key++;
13032
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
13033
0
  }
13034
13035
32
  if (RETURN_VALUE_USED(opline)) {
13036
    /* If the return value of yield is used set the send
13037
     * target and initialize it to NULL */
13038
3
    generator->send_target = EX_VAR(opline->result.var);
13039
3
    ZVAL_NULL(generator->send_target);
13040
29
  } else {
13041
29
    generator->send_target = NULL;
13042
29
  }
13043
13044
  /* The GOTO VM uses a local opline variable. We need to set the opline
13045
   * variable in execute_data so we don't resume at an old position. */
13046
32
  SAVE_OPLINE();
13047
13048
32
  ZEND_VM_RETURN();
13049
32
}
13050
13051
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13052
7.54k
{
13053
7.54k
  USE_OPLINE
13054
7.54k
  zval *op1;
13055
13056
7.54k
  op1 = EX_VAR(opline->op1.var);
13057
7.54k
  if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13058
2.93k
    ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
13059
2.93k
    ZEND_VM_NEXT_OPCODE();
13060
2.93k
  }
13061
13062
7.54k
  ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1));
13063
7.54k
}
13064
13065
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13066
1.00k
{
13067
1.00k
  USE_OPLINE
13068
1.00k
  zval *value;
13069
13070
1.00k
  value = EX_VAR(opline->op1.var);
13071
1.00k
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
13072
1.00k
  ZEND_VM_NEXT_OPCODE();
13073
1.00k
}
13074
13075
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13076
53
{
13077
53
  USE_OPLINE
13078
53
  zval *value;
13079
13080
53
  value = EX_VAR(opline->op1.var);
13081
53
  ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
13082
53
  ZEND_VM_NEXT_OPCODE();
13083
53
}
13084
13085
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13086
12.4k
{
13087
12.4k
  USE_OPLINE
13088
12.4k
  zval *value;
13089
13090
12.4k
  value = EX_VAR(opline->op1.var);
13091
12.4k
  ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
13092
12.4k
  ZEND_VM_NEXT_OPCODE();
13093
12.4k
}
13094
13095
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13096
7.53k
{
13097
7.53k
  USE_OPLINE
13098
7.53k
  zval *op1, *op2, *result;
13099
7.53k
  double d1, d2;
13100
13101
7.53k
  op1 = EX_VAR(opline->op1.var);
13102
7.53k
  op2 = RT_CONSTANT(opline, opline->op2);
13103
7.53k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13104
    /* pass */
13105
7.53k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13106
5.79k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13107
3.34k
      result = EX_VAR(opline->result.var);
13108
3.34k
      fast_long_add_function(result, op1, op2);
13109
3.34k
      ZEND_VM_NEXT_OPCODE();
13110
3.34k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13111
978
      d1 = (double)Z_LVAL_P(op1);
13112
978
      d2 = Z_DVAL_P(op2);
13113
978
      goto add_double;
13114
978
    }
13115
5.79k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13116
577
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13117
114
      d1 = Z_DVAL_P(op1);
13118
114
      d2 = Z_DVAL_P(op2);
13119
1.26k
add_double:
13120
1.26k
      result = EX_VAR(opline->result.var);
13121
1.26k
      ZVAL_DOUBLE(result, d1 + d2);
13122
1.26k
      ZEND_VM_NEXT_OPCODE();
13123
1.26k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13124
176
      d1 = Z_DVAL_P(op1);
13125
176
      d2 = (double)Z_LVAL_P(op2);
13126
176
      goto add_double;
13127
176
    }
13128
577
  }
13129
13130
7.53k
  ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13131
7.53k
}
13132
13133
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13134
11.5k
{
13135
11.5k
  USE_OPLINE
13136
11.5k
  zval *op1, *op2, *result;
13137
11.5k
  double d1, d2;
13138
13139
11.5k
  op1 = EX_VAR(opline->op1.var);
13140
11.5k
  op2 = RT_CONSTANT(opline, opline->op2);
13141
11.5k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13142
    /* pass */
13143
11.5k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13144
6.44k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13145
6.06k
      result = EX_VAR(opline->result.var);
13146
6.06k
      fast_long_sub_function(result, op1, op2);
13147
6.06k
      ZEND_VM_NEXT_OPCODE();
13148
6.06k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13149
121
      d1 = (double)Z_LVAL_P(op1);
13150
121
      d2 = Z_DVAL_P(op2);
13151
121
      goto sub_double;
13152
121
    }
13153
6.44k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13154
4.14k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13155
70
      d1 = Z_DVAL_P(op1);
13156
70
      d2 = Z_DVAL_P(op2);
13157
4.03k
sub_double:
13158
4.03k
      result = EX_VAR(opline->result.var);
13159
4.03k
      ZVAL_DOUBLE(result, d1 - d2);
13160
4.03k
      ZEND_VM_NEXT_OPCODE();
13161
4.07k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13162
3.84k
      d1 = Z_DVAL_P(op1);
13163
3.84k
      d2 = (double)Z_LVAL_P(op2);
13164
3.84k
      goto sub_double;
13165
3.84k
    }
13166
4.14k
  }
13167
13168
11.5k
  ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13169
11.5k
}
13170
13171
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13172
42.8k
{
13173
42.8k
  USE_OPLINE
13174
42.8k
  zval *op1, *op2, *result;
13175
42.8k
  double d1, d2;
13176
13177
42.8k
  op1 = EX_VAR(opline->op1.var);
13178
42.8k
  op2 = RT_CONSTANT(opline, opline->op2);
13179
42.8k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13180
    /* pass */
13181
42.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13182
6.52k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13183
6.12k
      zend_long overflow;
13184
13185
6.12k
      result = EX_VAR(opline->result.var);
13186
6.12k
      ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13187
6.12k
      Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13188
6.12k
      ZEND_VM_NEXT_OPCODE();
13189
6.12k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13190
398
      d1 = (double)Z_LVAL_P(op1);
13191
398
      d2 = Z_DVAL_P(op2);
13192
398
      goto mul_double;
13193
398
    }
13194
36.2k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13195
1.73k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13196
174
      d1 = Z_DVAL_P(op1);
13197
174
      d2 = Z_DVAL_P(op2);
13198
2.03k
mul_double:
13199
2.03k
      result = EX_VAR(opline->result.var);
13200
2.03k
      ZVAL_DOUBLE(result, d1 * d2);
13201
2.03k
      ZEND_VM_NEXT_OPCODE();
13202
2.03k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13203
1.46k
      d1 = Z_DVAL_P(op1);
13204
1.46k
      d2 = (double)Z_LVAL_P(op2);
13205
1.46k
      goto mul_double;
13206
1.46k
    }
13207
1.73k
  }
13208
13209
42.8k
  ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13210
42.8k
}
13211
13212
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13213
2.32k
{
13214
2.32k
  USE_OPLINE
13215
2.32k
  zval *op1, *op2, *result;
13216
13217
2.32k
  op1 = EX_VAR(opline->op1.var);
13218
2.32k
  op2 = RT_CONSTANT(opline, opline->op2);
13219
2.32k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13220
    /* pass */
13221
2.32k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13222
2.16k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13223
1.94k
      result = EX_VAR(opline->result.var);
13224
1.94k
      if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
13225
12
        ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
13226
1.92k
      } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
13227
        /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
13228
10
        ZVAL_LONG(result, 0);
13229
1.91k
      } else {
13230
1.91k
        ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
13231
1.91k
      }
13232
1.92k
      ZEND_VM_NEXT_OPCODE();
13233
1.92k
    }
13234
2.16k
  }
13235
13236
2.32k
  ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13237
2.32k
}
13238
13239
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13240
1.58k
{
13241
1.58k
  USE_OPLINE
13242
1.58k
  zval *op1, *op2;
13243
13244
1.58k
  op1 = EX_VAR(opline->op1.var);
13245
1.58k
  op2 = RT_CONSTANT(opline, opline->op2);
13246
1.58k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13247
    /* pass */
13248
1.58k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13249
1.58k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13250
1.58k
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13251
    /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
13252
34
    ZVAL_LONG(EX_VAR(opline->result.var),
13253
34
      (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
13254
34
    ZEND_VM_NEXT_OPCODE();
13255
34
  }
13256
13257
1.58k
  ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13258
1.58k
}
13259
13260
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13261
1.13k
{
13262
1.13k
  USE_OPLINE
13263
1.13k
  zval *op1, *op2;
13264
13265
1.13k
  op1 = EX_VAR(opline->op1.var);
13266
1.13k
  op2 = RT_CONSTANT(opline, opline->op2);
13267
1.13k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13268
    /* pass */
13269
1.13k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13270
1.13k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13271
1.13k
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13272
1.08k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
13273
1.08k
    ZEND_VM_NEXT_OPCODE();
13274
1.08k
  }
13275
13276
1.13k
  ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13277
1.13k
}
13278
13279
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13280
4.21k
{
13281
4.21k
  USE_OPLINE
13282
4.21k
  zval *op1, *op2;
13283
4.21k
  double d1, d2;
13284
13285
4.21k
  op1 = EX_VAR(opline->op1.var);
13286
4.21k
  op2 = RT_CONSTANT(opline, opline->op2);
13287
4.21k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13288
    /* pass */
13289
4.21k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13290
2.00k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13291
1.56k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13292
1.72k
is_smaller_true:
13293
1.72k
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
13294
1.72k
      } else {
13295
76
is_smaller_false:
13296
76
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
13297
76
      }
13298
1.56k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13299
211
      d1 = (double)Z_LVAL_P(op1);
13300
211
      d2 = Z_DVAL_P(op2);
13301
211
      goto is_smaller_double;
13302
211
    }
13303
2.21k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13304
79
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13305
5
      d1 = Z_DVAL_P(op1);
13306
5
      d2 = Z_DVAL_P(op2);
13307
242
is_smaller_double:
13308
242
      if (d1 < d2) {
13309
242
        goto is_smaller_true;
13310
242
      } else {
13311
0
        goto is_smaller_false;
13312
0
      }
13313
242
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13314
26
      d1 = Z_DVAL_P(op1);
13315
26
      d2 = (double)Z_LVAL_P(op2);
13316
26
      goto is_smaller_double;
13317
26
    }
13318
79
  }
13319
4.21k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13320
4.21k
}
13321
13322
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13323
1.22k
{
13324
1.22k
  USE_OPLINE
13325
1.22k
  zval *op1, *op2;
13326
1.22k
  double d1, d2;
13327
13328
1.22k
  op1 = EX_VAR(opline->op1.var);
13329
1.22k
  op2 = RT_CONSTANT(opline, opline->op2);
13330
1.22k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13331
    /* pass */
13332
1.22k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13333
1.05k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13334
851
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13335
559
is_smaller_true:
13336
559
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13337
559
      } else {
13338
543
is_smaller_false:
13339
543
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13340
543
      }
13341
851
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13342
206
      d1 = (double)Z_LVAL_P(op1);
13343
206
      d2 = Z_DVAL_P(op2);
13344
206
      goto is_smaller_double;
13345
206
    }
13346
1.05k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13347
47
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13348
0
      d1 = Z_DVAL_P(op1);
13349
0
      d2 = Z_DVAL_P(op2);
13350
251
is_smaller_double:
13351
251
      if (d1 < d2) {
13352
209
        goto is_smaller_true;
13353
209
      } else {
13354
42
        goto is_smaller_false;
13355
42
      }
13356
251
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13357
45
      d1 = Z_DVAL_P(op1);
13358
45
      d2 = (double)Z_LVAL_P(op2);
13359
45
      goto is_smaller_double;
13360
45
    }
13361
47
  }
13362
1.22k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13363
1.22k
}
13364
13365
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13366
324k
{
13367
324k
  USE_OPLINE
13368
324k
  zval *op1, *op2;
13369
324k
  double d1, d2;
13370
13371
324k
  op1 = EX_VAR(opline->op1.var);
13372
324k
  op2 = RT_CONSTANT(opline, opline->op2);
13373
324k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13374
    /* pass */
13375
324k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13376
308k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13377
306k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13378
307k
is_smaller_true:
13379
307k
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13380
307k
      } else {
13381
1.94k
is_smaller_false:
13382
1.94k
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13383
1.94k
      }
13384
306k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13385
1.18k
      d1 = (double)Z_LVAL_P(op1);
13386
1.18k
      d2 = Z_DVAL_P(op2);
13387
1.18k
      goto is_smaller_double;
13388
1.18k
    }
13389
308k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13390
1.14k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13391
80
      d1 = Z_DVAL_P(op1);
13392
80
      d2 = Z_DVAL_P(op2);
13393
2.32k
is_smaller_double:
13394
2.32k
      if (d1 < d2) {
13395
2.04k
        goto is_smaller_true;
13396
2.04k
      } else {
13397
286
        goto is_smaller_false;
13398
286
      }
13399
2.32k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13400
1.06k
      d1 = Z_DVAL_P(op1);
13401
1.06k
      d2 = (double)Z_LVAL_P(op2);
13402
1.06k
      goto is_smaller_double;
13403
1.06k
    }
13404
1.14k
  }
13405
324k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13406
324k
}
13407
13408
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13409
140
{
13410
140
  USE_OPLINE
13411
140
  zval *op1, *op2;
13412
140
  double d1, d2;
13413
13414
140
  op1 = EX_VAR(opline->op1.var);
13415
140
  op2 = RT_CONSTANT(opline, opline->op2);
13416
140
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13417
    /* pass */
13418
140
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13419
27
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13420
0
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13421
1
is_smaller_or_equal_true:
13422
1
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
13423
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
13424
0
        ZEND_VM_NEXT_OPCODE();
13425
0
      } else {
13426
0
is_smaller_or_equal_false:
13427
0
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
13428
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
13429
0
        ZEND_VM_NEXT_OPCODE();
13430
0
      }
13431
27
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13432
0
      d1 = (double)Z_LVAL_P(op1);
13433
0
      d2 = Z_DVAL_P(op2);
13434
0
      goto is_smaller_or_equal_double;
13435
0
    }
13436
113
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13437
18
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13438
1
      d1 = Z_DVAL_P(op1);
13439
1
      d2 = Z_DVAL_P(op2);
13440
1
is_smaller_or_equal_double:
13441
1
      if (d1 <= d2) {
13442
1
        goto is_smaller_or_equal_true;
13443
1
      } else {
13444
0
        goto is_smaller_or_equal_false;
13445
0
      }
13446
17
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13447
0
      d1 = Z_DVAL_P(op1);
13448
0
      d2 = (double)Z_LVAL_P(op2);
13449
0
      goto is_smaller_or_equal_double;
13450
0
    }
13451
18
  }
13452
140
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13453
140
}
13454
13455
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13456
3.28k
{
13457
3.28k
  USE_OPLINE
13458
3.28k
  zval *op1, *op2;
13459
3.28k
  double d1, d2;
13460
13461
3.28k
  op1 = EX_VAR(opline->op1.var);
13462
3.28k
  op2 = RT_CONSTANT(opline, opline->op2);
13463
3.28k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13464
    /* pass */
13465
3.28k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13466
780
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13467
718
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13468
637
is_smaller_or_equal_true:
13469
637
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13470
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
13471
0
        ZEND_VM_NEXT_OPCODE();
13472
197
      } else {
13473
200
is_smaller_or_equal_false:
13474
200
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13475
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
13476
0
        ZEND_VM_NEXT_OPCODE();
13477
0
      }
13478
718
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13479
59
      d1 = (double)Z_LVAL_P(op1);
13480
59
      d2 = Z_DVAL_P(op2);
13481
59
      goto is_smaller_or_equal_double;
13482
59
    }
13483
2.50k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13484
63
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13485
57
      d1 = Z_DVAL_P(op1);
13486
57
      d2 = Z_DVAL_P(op2);
13487
119
is_smaller_or_equal_double:
13488
119
      if (d1 <= d2) {
13489
116
        goto is_smaller_or_equal_true;
13490
116
      } else {
13491
3
        goto is_smaller_or_equal_false;
13492
3
      }
13493
119
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13494
3
      d1 = Z_DVAL_P(op1);
13495
3
      d2 = (double)Z_LVAL_P(op2);
13496
3
      goto is_smaller_or_equal_double;
13497
3
    }
13498
63
  }
13499
3.28k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13500
3.28k
}
13501
13502
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13503
14.4k
{
13504
14.4k
  USE_OPLINE
13505
14.4k
  zval *op1, *op2;
13506
14.4k
  double d1, d2;
13507
13508
14.4k
  op1 = EX_VAR(opline->op1.var);
13509
14.4k
  op2 = RT_CONSTANT(opline, opline->op2);
13510
14.4k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13511
    /* pass */
13512
14.4k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13513
12.1k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13514
7.43k
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13515
8.58k
is_smaller_or_equal_true:
13516
8.58k
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13517
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
13518
0
        ZEND_VM_NEXT_OPCODE();
13519
1.27k
      } else {
13520
3.17k
is_smaller_or_equal_false:
13521
3.17k
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13522
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
13523
0
        ZEND_VM_NEXT_OPCODE();
13524
0
      }
13525
7.43k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13526
4.32k
      d1 = (double)Z_LVAL_P(op1);
13527
4.32k
      d2 = Z_DVAL_P(op2);
13528
4.32k
      goto is_smaller_or_equal_double;
13529
4.32k
    }
13530
12.1k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13531
2
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13532
0
      d1 = Z_DVAL_P(op1);
13533
0
      d2 = Z_DVAL_P(op2);
13534
4.32k
is_smaller_or_equal_double:
13535
4.32k
      if (d1 <= d2) {
13536
2.41k
        goto is_smaller_or_equal_true;
13537
2.41k
      } else {
13538
1.90k
        goto is_smaller_or_equal_false;
13539
1.90k
      }
13540
4.32k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13541
2
      d1 = Z_DVAL_P(op1);
13542
2
      d2 = (double)Z_LVAL_P(op2);
13543
2
      goto is_smaller_or_equal_double;
13544
2
    }
13545
2
  }
13546
14.4k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13547
14.4k
}
13548
13549
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13550
5.39k
{
13551
5.39k
  USE_OPLINE
13552
5.39k
  zval *op1, *op2;
13553
13554
5.39k
  op1 = EX_VAR(opline->op1.var);
13555
5.39k
  op2 = RT_CONSTANT(opline, opline->op2);
13556
5.39k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13557
    /* pass */
13558
5.39k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13559
5.39k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13560
492
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
13561
492
    ZEND_VM_NEXT_OPCODE();
13562
492
  }
13563
13564
5.39k
  ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13565
5.39k
}
13566
13567
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13568
5.34k
{
13569
5.34k
  USE_OPLINE
13570
5.34k
  zval *op1, *op2;
13571
13572
5.34k
  op1 = EX_VAR(opline->op1.var);
13573
5.34k
  op2 = RT_CONSTANT(opline, opline->op2);
13574
5.34k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13575
    /* pass */
13576
5.34k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13577
5.34k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13578
2.60k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
13579
2.60k
    ZEND_VM_NEXT_OPCODE();
13580
2.60k
  }
13581
13582
5.34k
  ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13583
5.34k
}
13584
13585
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13586
32.3k
{
13587
32.3k
  USE_OPLINE
13588
32.3k
  zval *op1, *op2;
13589
13590
32.3k
  op1 = EX_VAR(opline->op1.var);
13591
32.3k
  op2 = RT_CONSTANT(opline, opline->op2);
13592
32.3k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13593
    /* pass */
13594
32.3k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13595
32.3k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13596
19.7k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
13597
19.7k
    ZEND_VM_NEXT_OPCODE();
13598
19.7k
  }
13599
13600
32.3k
  ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
13601
32.3k
}
13602
13603
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13604
2.91k
{
13605
2.91k
  USE_OPLINE
13606
2.91k
  zval *container;
13607
13608
2.91k
  SAVE_OPLINE();
13609
2.91k
  container = EX_VAR(opline->op1.var);
13610
2.91k
  zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
13611
13612
2.91k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
13613
2.91k
}
13614
13615
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13616
5
{
13617
5
  USE_OPLINE
13618
5
  zval *op, *jump_zv;
13619
5
  HashTable *jumptable;
13620
13621
5
  op = EX_VAR(opline->op1.var);
13622
13623
5
  if (Z_TYPE_P(op) != IS_LONG) {
13624
0
    ZVAL_DEREF(op);
13625
0
    if (Z_TYPE_P(op) != IS_LONG) {
13626
      /* Wrong type, fall back to ZEND_CASE chain */
13627
0
      ZEND_VM_NEXT_OPCODE();
13628
0
    }
13629
0
  }
13630
13631
5
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13632
5
  jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13633
5
  if (jump_zv != NULL) {
13634
5
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13635
5
    ZEND_VM_CONTINUE();
13636
5
  } else {
13637
    /* default */
13638
0
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13639
0
    ZEND_VM_CONTINUE();
13640
0
  }
13641
5
}
13642
13643
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13644
524
{
13645
524
  USE_OPLINE
13646
524
  zval *op, *jump_zv;
13647
524
  HashTable *jumptable;
13648
13649
524
  op = EX_VAR(opline->op1.var);
13650
13651
524
  if (Z_TYPE_P(op) != IS_STRING) {
13652
29
    if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13653
      /* Wrong type, fall back to ZEND_CASE chain */
13654
0
      ZEND_VM_NEXT_OPCODE();
13655
29
    } else {
13656
29
      ZVAL_DEREF(op);
13657
29
      if (Z_TYPE_P(op) != IS_STRING) {
13658
        /* Wrong type, fall back to ZEND_CASE chain */
13659
29
        ZEND_VM_NEXT_OPCODE();
13660
29
      }
13661
29
    }
13662
29
  }
13663
13664
495
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13665
495
  jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13666
495
  if (jump_zv != NULL) {
13667
47
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13668
47
    ZEND_VM_CONTINUE();
13669
448
  } else {
13670
    /* default */
13671
448
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13672
448
    ZEND_VM_CONTINUE();
13673
448
  }
13674
495
}
13675
13676
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13677
387
{
13678
387
  USE_OPLINE
13679
387
  zval *op, *jump_zv;
13680
387
  HashTable *jumptable;
13681
13682
387
  op = EX_VAR(opline->op1.var);
13683
387
  jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13684
13685
399
match_try_again:
13686
399
  if (Z_TYPE_P(op) == IS_LONG) {
13687
231
    jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13688
231
  } else if (Z_TYPE_P(op) == IS_STRING) {
13689
142
    jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13690
142
  } else if (Z_TYPE_P(op) == IS_REFERENCE) {
13691
0
    op = Z_REFVAL_P(op);
13692
0
    goto match_try_again;
13693
26
  } else {
13694
26
    if (UNEXPECTED(((IS_TMP_VAR|IS_VAR|IS_CV) & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
13695
12
      SAVE_OPLINE();
13696
12
      op = ZVAL_UNDEFINED_OP1();
13697
12
      if (UNEXPECTED(EG(exception))) {
13698
0
        HANDLE_EXCEPTION();
13699
0
      }
13700
12
      goto match_try_again;
13701
12
    }
13702
13703
14
    goto default_branch;
13704
26
  }
13705
13706
373
  if (jump_zv != NULL) {
13707
196
    ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13708
196
    ZEND_VM_CONTINUE();
13709
196
  } else {
13710
191
default_branch:
13711
    /* default */
13712
191
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13713
191
    ZEND_VM_CONTINUE();
13714
191
  }
13715
373
}
13716
13717
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13718
1.52k
{
13719
1.52k
  USE_OPLINE
13720
1.52k
  zval *op1, *op2, *result;
13721
13722
1.52k
  op1 = EX_VAR(opline->op1.var);
13723
1.52k
  op2 = RT_CONSTANT(opline, opline->op2);
13724
1.52k
  result = EX_VAR(opline->result.var);
13725
1.52k
  ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
13726
1.52k
  ZEND_VM_NEXT_OPCODE();
13727
1.52k
}
13728
13729
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13730
784
{
13731
784
  USE_OPLINE
13732
784
  zval *op1, *op2, *result;
13733
13734
784
  op1 = EX_VAR(opline->op1.var);
13735
784
  op2 = RT_CONSTANT(opline, opline->op2);
13736
784
  result = EX_VAR(opline->result.var);
13737
784
  fast_long_add_function(result, op1, op2);
13738
784
  ZEND_VM_NEXT_OPCODE();
13739
784
}
13740
13741
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13742
272
{
13743
272
  USE_OPLINE
13744
272
  zval *op1, *op2, *result;
13745
13746
272
  op1 = EX_VAR(opline->op1.var);
13747
272
  op2 = RT_CONSTANT(opline, opline->op2);
13748
272
  result = EX_VAR(opline->result.var);
13749
272
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
13750
272
  ZEND_VM_NEXT_OPCODE();
13751
272
}
13752
13753
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13754
1.08k
{
13755
1.08k
  USE_OPLINE
13756
1.08k
  zval *op1, *op2, *result;
13757
13758
1.08k
  op1 = EX_VAR(opline->op1.var);
13759
1.08k
  op2 = RT_CONSTANT(opline, opline->op2);
13760
1.08k
  result = EX_VAR(opline->result.var);
13761
1.08k
  ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
13762
1.08k
  ZEND_VM_NEXT_OPCODE();
13763
1.08k
}
13764
13765
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13766
2.16k
{
13767
2.16k
  USE_OPLINE
13768
2.16k
  zval *op1, *op2, *result;
13769
13770
2.16k
  op1 = EX_VAR(opline->op1.var);
13771
2.16k
  op2 = RT_CONSTANT(opline, opline->op2);
13772
2.16k
  result = EX_VAR(opline->result.var);
13773
2.16k
  fast_long_sub_function(result, op1, op2);
13774
2.16k
  ZEND_VM_NEXT_OPCODE();
13775
2.16k
}
13776
13777
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13778
218
{
13779
218
  USE_OPLINE
13780
218
  zval *op1, *op2, *result;
13781
13782
218
  op1 = EX_VAR(opline->op1.var);
13783
218
  op2 = RT_CONSTANT(opline, opline->op2);
13784
218
  result = EX_VAR(opline->result.var);
13785
218
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
13786
218
  ZEND_VM_NEXT_OPCODE();
13787
218
}
13788
13789
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13790
122
{
13791
122
  USE_OPLINE
13792
122
  zval *op1, *op2, *result;
13793
13794
122
  op1 = EX_VAR(opline->op1.var);
13795
122
  op2 = RT_CONSTANT(opline, opline->op2);
13796
122
  result = EX_VAR(opline->result.var);
13797
122
  ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
13798
122
  ZEND_VM_NEXT_OPCODE();
13799
122
}
13800
13801
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13802
1.45k
{
13803
1.45k
  USE_OPLINE
13804
1.45k
  zval *op1, *op2, *result;
13805
1.45k
  zend_long overflow;
13806
13807
1.45k
  op1 = EX_VAR(opline->op1.var);
13808
1.45k
  op2 = RT_CONSTANT(opline, opline->op2);
13809
1.45k
  result = EX_VAR(opline->result.var);
13810
1.45k
  ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13811
1.45k
  Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13812
1.45k
  ZEND_VM_NEXT_OPCODE();
13813
1.45k
}
13814
13815
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13816
69
{
13817
69
  USE_OPLINE
13818
69
  zval *op1, *op2, *result;
13819
13820
69
  op1 = EX_VAR(opline->op1.var);
13821
69
  op2 = RT_CONSTANT(opline, opline->op2);
13822
69
  result = EX_VAR(opline->result.var);
13823
69
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
13824
69
  ZEND_VM_NEXT_OPCODE();
13825
69
}
13826
13827
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13828
478
{
13829
478
  USE_OPLINE
13830
478
  zval *op1, *op2;
13831
478
  bool result;
13832
13833
478
  op1 = EX_VAR(opline->op1.var);
13834
478
  op2 = RT_CONSTANT(opline, opline->op2);
13835
478
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13836
478
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13837
478
}
13838
13839
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13840
1.82k
{
13841
1.82k
  USE_OPLINE
13842
1.82k
  zval *op1, *op2;
13843
1.82k
  bool result;
13844
13845
1.82k
  op1 = EX_VAR(opline->op1.var);
13846
1.82k
  op2 = RT_CONSTANT(opline, opline->op2);
13847
1.82k
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13848
1.82k
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13849
1.82k
}
13850
13851
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13852
120
{
13853
120
  USE_OPLINE
13854
120
  zval *op1, *op2;
13855
120
  bool result;
13856
13857
120
  op1 = EX_VAR(opline->op1.var);
13858
120
  op2 = RT_CONSTANT(opline, opline->op2);
13859
120
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13860
120
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13861
120
}
13862
13863
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13864
112
{
13865
112
  USE_OPLINE
13866
112
  zval *op1, *op2;
13867
112
  bool result;
13868
13869
112
  op1 = EX_VAR(opline->op1.var);
13870
112
  op2 = RT_CONSTANT(opline, opline->op2);
13871
112
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13872
112
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13873
112
}
13874
13875
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13876
202
{
13877
202
  USE_OPLINE
13878
202
  zval *op1, *op2;
13879
202
  bool result;
13880
13881
202
  op1 = EX_VAR(opline->op1.var);
13882
202
  op2 = RT_CONSTANT(opline, opline->op2);
13883
202
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13884
202
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13885
202
}
13886
13887
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13888
0
{
13889
0
  USE_OPLINE
13890
0
  zval *op1, *op2;
13891
0
  bool result;
13892
13893
0
  op1 = EX_VAR(opline->op1.var);
13894
0
  op2 = RT_CONSTANT(opline, opline->op2);
13895
0
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13896
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13897
0
}
13898
13899
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13900
0
{
13901
0
  USE_OPLINE
13902
0
  zval *op1, *op2;
13903
0
  bool result;
13904
13905
0
  op1 = EX_VAR(opline->op1.var);
13906
0
  op2 = RT_CONSTANT(opline, opline->op2);
13907
0
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13908
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13909
0
}
13910
13911
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13912
36
{
13913
36
  USE_OPLINE
13914
36
  zval *op1, *op2;
13915
36
  bool result;
13916
13917
36
  op1 = EX_VAR(opline->op1.var);
13918
36
  op2 = RT_CONSTANT(opline, opline->op2);
13919
36
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13920
36
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13921
36
}
13922
13923
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13924
662
{
13925
662
  USE_OPLINE
13926
662
  zval *op1, *op2;
13927
662
  bool result;
13928
13929
662
  op1 = EX_VAR(opline->op1.var);
13930
662
  op2 = RT_CONSTANT(opline, opline->op2);
13931
662
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13932
662
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13933
662
}
13934
13935
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13936
0
{
13937
0
  USE_OPLINE
13938
0
  zval *op1, *op2;
13939
0
  bool result;
13940
13941
0
  op1 = EX_VAR(opline->op1.var);
13942
0
  op2 = RT_CONSTANT(opline, opline->op2);
13943
0
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13944
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13945
0
}
13946
13947
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13948
0
{
13949
0
  USE_OPLINE
13950
0
  zval *op1, *op2;
13951
0
  bool result;
13952
13953
0
  op1 = EX_VAR(opline->op1.var);
13954
0
  op2 = RT_CONSTANT(opline, opline->op2);
13955
0
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13956
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13957
0
}
13958
13959
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13960
0
{
13961
0
  USE_OPLINE
13962
0
  zval *op1, *op2;
13963
0
  bool result;
13964
13965
0
  op1 = EX_VAR(opline->op1.var);
13966
0
  op2 = RT_CONSTANT(opline, opline->op2);
13967
0
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13968
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13969
0
}
13970
13971
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13972
0
{
13973
0
  USE_OPLINE
13974
0
  zval *op1;
13975
0
  bool result;
13976
13977
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
13978
0
  result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0;
13979
0
  FREE_OP(opline->op1_type, opline->op1.var);
13980
13981
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
13982
0
}
13983
13984
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13985
0
{
13986
0
  USE_OPLINE
13987
0
  zval *op1;
13988
0
  bool result;
13989
13990
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
13991
0
  result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0;
13992
0
  FREE_OP(opline->op1_type, opline->op1.var);
13993
13994
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13995
0
}
13996
13997
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13998
0
{
13999
0
  USE_OPLINE
14000
0
  zval *op1;
14001
0
  bool result;
14002
14003
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
14004
0
  result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0;
14005
0
  FREE_OP(opline->op1_type, opline->op1.var);
14006
14007
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14008
0
}
14009
14010
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14011
0
{
14012
0
  USE_OPLINE
14013
0
  zval *op1;
14014
0
  bool result;
14015
14016
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
14017
0
  result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0;
14018
0
  FREE_OP(opline->op1_type, opline->op1.var);
14019
14020
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14021
0
}
14022
14023
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14024
0
{
14025
0
  USE_OPLINE
14026
0
  zval *op1;
14027
0
  bool result;
14028
14029
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
14030
0
  result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0;
14031
0
  FREE_OP(opline->op1_type, opline->op1.var);
14032
14033
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14034
0
}
14035
14036
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14037
0
{
14038
0
  USE_OPLINE
14039
0
  zval *op1;
14040
0
  bool result;
14041
14042
0
  op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC);
14043
0
  result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0;
14044
0
  FREE_OP(opline->op1_type, opline->op1.var);
14045
14046
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14047
0
}
14048
14049
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14050
73
{
14051
73
  USE_OPLINE
14052
73
  zval *op1, *op2;
14053
73
  bool result;
14054
14055
73
  op1 = EX_VAR(opline->op1.var);
14056
73
  op2 = RT_CONSTANT(opline, opline->op2);
14057
73
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14058
73
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14059
73
}
14060
14061
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14062
1.22k
{
14063
1.22k
  USE_OPLINE
14064
1.22k
  zval *op1, *op2;
14065
1.22k
  bool result;
14066
14067
1.22k
  op1 = EX_VAR(opline->op1.var);
14068
1.22k
  op2 = RT_CONSTANT(opline, opline->op2);
14069
1.22k
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14070
1.22k
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14071
1.22k
}
14072
14073
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14074
14.2k
{
14075
14.2k
  USE_OPLINE
14076
14.2k
  zval *op1, *op2;
14077
14.2k
  bool result;
14078
14079
14.2k
  op1 = EX_VAR(opline->op1.var);
14080
14.2k
  op2 = RT_CONSTANT(opline, opline->op2);
14081
14.2k
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14082
14.2k
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14083
14.2k
}
14084
14085
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14086
145
{
14087
145
  USE_OPLINE
14088
145
  zval *op1, *op2;
14089
145
  bool result;
14090
14091
145
  op1 = EX_VAR(opline->op1.var);
14092
145
  op2 = RT_CONSTANT(opline, opline->op2);
14093
145
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14094
145
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14095
145
}
14096
14097
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14098
0
{
14099
0
  USE_OPLINE
14100
0
  zval *op1, *op2;
14101
0
  bool result;
14102
14103
0
  op1 = EX_VAR(opline->op1.var);
14104
0
  op2 = RT_CONSTANT(opline, opline->op2);
14105
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14106
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14107
0
}
14108
14109
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14110
0
{
14111
0
  USE_OPLINE
14112
0
  zval *op1, *op2;
14113
0
  bool result;
14114
14115
0
  op1 = EX_VAR(opline->op1.var);
14116
0
  op2 = RT_CONSTANT(opline, opline->op2);
14117
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14118
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14119
0
}
14120
14121
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14122
0
{
14123
0
  USE_OPLINE
14124
0
  zval *op1, *op2;
14125
0
  bool result;
14126
14127
0
  op1 = EX_VAR(opline->op1.var);
14128
0
  op2 = RT_CONSTANT(opline, opline->op2);
14129
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14130
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14131
0
}
14132
14133
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)
14134
151
{
14135
151
  USE_OPLINE
14136
151
  zval *op1, *op2;
14137
151
  bool result;
14138
14139
151
  op1 = EX_VAR(opline->op1.var);
14140
151
  op2 = RT_CONSTANT(opline, opline->op2);
14141
151
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14142
151
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14143
151
}
14144
14145
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)
14146
1.99k
{
14147
1.99k
  USE_OPLINE
14148
1.99k
  zval *op1, *op2;
14149
1.99k
  bool result;
14150
14151
1.99k
  op1 = EX_VAR(opline->op1.var);
14152
1.99k
  op2 = RT_CONSTANT(opline, opline->op2);
14153
1.99k
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14154
1.99k
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14155
1.99k
}
14156
14157
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14158
0
{
14159
0
  USE_OPLINE
14160
0
  zval *op1, *op2;
14161
0
  bool result;
14162
14163
0
  op1 = EX_VAR(opline->op1.var);
14164
0
  op2 = RT_CONSTANT(opline, opline->op2);
14165
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14166
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14167
0
}
14168
14169
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)
14170
0
{
14171
0
  USE_OPLINE
14172
0
  zval *op1, *op2;
14173
0
  bool result;
14174
14175
0
  op1 = EX_VAR(opline->op1.var);
14176
0
  op2 = RT_CONSTANT(opline, opline->op2);
14177
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14178
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14179
0
}
14180
14181
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)
14182
0
{
14183
0
  USE_OPLINE
14184
0
  zval *op1, *op2;
14185
0
  bool result;
14186
14187
0
  op1 = EX_VAR(opline->op1.var);
14188
0
  op2 = RT_CONSTANT(opline, opline->op2);
14189
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14190
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14191
0
}
14192
14193
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14194
82.8k
{
14195
82.8k
  USE_OPLINE
14196
82.8k
  zval *op1, *op2, *result;
14197
82.8k
  double d1, d2;
14198
14199
82.8k
  op1 = EX_VAR(opline->op1.var);
14200
82.8k
  op2 = EX_VAR(opline->op2.var);
14201
82.8k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14202
    /* pass */
14203
82.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14204
47.0k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14205
35.6k
      result = EX_VAR(opline->result.var);
14206
35.6k
      fast_long_add_function(result, op1, op2);
14207
35.6k
      ZEND_VM_NEXT_OPCODE();
14208
35.6k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14209
1.70k
      d1 = (double)Z_LVAL_P(op1);
14210
1.70k
      d2 = Z_DVAL_P(op2);
14211
1.70k
      goto add_double;
14212
1.70k
    }
14213
47.0k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14214
17.0k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14215
9.20k
      d1 = Z_DVAL_P(op1);
14216
9.20k
      d2 = Z_DVAL_P(op2);
14217
13.0k
add_double:
14218
13.0k
      result = EX_VAR(opline->result.var);
14219
13.0k
      ZVAL_DOUBLE(result, d1 + d2);
14220
13.0k
      ZEND_VM_NEXT_OPCODE();
14221
13.0k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14222
2.17k
      d1 = Z_DVAL_P(op1);
14223
2.17k
      d2 = (double)Z_LVAL_P(op2);
14224
2.17k
      goto add_double;
14225
2.17k
    }
14226
17.0k
  }
14227
14228
82.8k
  ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14229
82.8k
}
14230
14231
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14232
7.80k
{
14233
7.80k
  USE_OPLINE
14234
7.80k
  zval *op1, *op2, *result;
14235
7.80k
  double d1, d2;
14236
14237
7.80k
  op1 = EX_VAR(opline->op1.var);
14238
7.80k
  op2 = EX_VAR(opline->op2.var);
14239
7.80k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14240
    /* pass */
14241
7.80k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14242
3.92k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14243
2.87k
      result = EX_VAR(opline->result.var);
14244
2.87k
      fast_long_sub_function(result, op1, op2);
14245
2.87k
      ZEND_VM_NEXT_OPCODE();
14246
2.87k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14247
29
      d1 = (double)Z_LVAL_P(op1);
14248
29
      d2 = Z_DVAL_P(op2);
14249
29
      goto sub_double;
14250
29
    }
14251
3.92k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14252
1.09k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14253
558
      d1 = Z_DVAL_P(op1);
14254
558
      d2 = Z_DVAL_P(op2);
14255
959
sub_double:
14256
959
      result = EX_VAR(opline->result.var);
14257
959
      ZVAL_DOUBLE(result, d1 - d2);
14258
959
      ZEND_VM_NEXT_OPCODE();
14259
959
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14260
372
      d1 = Z_DVAL_P(op1);
14261
372
      d2 = (double)Z_LVAL_P(op2);
14262
372
      goto sub_double;
14263
372
    }
14264
1.09k
  }
14265
14266
7.80k
  ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14267
7.80k
}
14268
14269
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14270
6.41k
{
14271
6.41k
  USE_OPLINE
14272
6.41k
  zval *op1, *op2, *result;
14273
6.41k
  double d1, d2;
14274
14275
6.41k
  op1 = EX_VAR(opline->op1.var);
14276
6.41k
  op2 = EX_VAR(opline->op2.var);
14277
6.41k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14278
    /* pass */
14279
6.41k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14280
2.90k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14281
2.33k
      zend_long overflow;
14282
14283
2.33k
      result = EX_VAR(opline->result.var);
14284
2.33k
      ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14285
2.33k
      Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14286
2.33k
      ZEND_VM_NEXT_OPCODE();
14287
2.33k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14288
134
      d1 = (double)Z_LVAL_P(op1);
14289
134
      d2 = Z_DVAL_P(op2);
14290
134
      goto mul_double;
14291
134
    }
14292
3.50k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14293
1.08k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14294
1.00k
      d1 = Z_DVAL_P(op1);
14295
1.00k
      d2 = Z_DVAL_P(op2);
14296
1.21k
mul_double:
14297
1.21k
      result = EX_VAR(opline->result.var);
14298
1.21k
      ZVAL_DOUBLE(result, d1 * d2);
14299
1.21k
      ZEND_VM_NEXT_OPCODE();
14300
1.21k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14301
76
      d1 = Z_DVAL_P(op1);
14302
76
      d2 = (double)Z_LVAL_P(op2);
14303
76
      goto mul_double;
14304
76
    }
14305
1.08k
  }
14306
14307
6.41k
  ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14308
6.41k
}
14309
14310
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14311
4.09k
{
14312
4.09k
  USE_OPLINE
14313
4.09k
  zval *op1, *op2, *result;
14314
14315
4.09k
  op1 = EX_VAR(opline->op1.var);
14316
4.09k
  op2 = EX_VAR(opline->op2.var);
14317
4.09k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14318
    /* pass */
14319
4.09k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14320
3.12k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14321
3.09k
      result = EX_VAR(opline->result.var);
14322
3.09k
      if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
14323
32
        ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
14324
3.06k
      } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
14325
        /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
14326
45
        ZVAL_LONG(result, 0);
14327
3.01k
      } else {
14328
3.01k
        ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
14329
3.01k
      }
14330
3.06k
      ZEND_VM_NEXT_OPCODE();
14331
3.06k
    }
14332
3.12k
  }
14333
14334
4.09k
  ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14335
4.09k
}
14336
14337
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14338
875
{
14339
875
  USE_OPLINE
14340
875
  zval *op1, *op2;
14341
14342
875
  op1 = EX_VAR(opline->op1.var);
14343
875
  op2 = EX_VAR(opline->op2.var);
14344
875
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14345
    /* pass */
14346
875
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14347
875
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
14348
875
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
14349
    /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
14350
707
    ZVAL_LONG(EX_VAR(opline->result.var),
14351
707
      (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
14352
707
    ZEND_VM_NEXT_OPCODE();
14353
707
  }
14354
14355
875
  ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14356
875
}
14357
14358
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14359
792
{
14360
792
  USE_OPLINE
14361
792
  zval *op1, *op2;
14362
14363
792
  op1 = EX_VAR(opline->op1.var);
14364
792
  op2 = EX_VAR(opline->op2.var);
14365
792
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14366
    /* pass */
14367
792
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14368
792
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
14369
792
      && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
14370
433
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
14371
433
    ZEND_VM_NEXT_OPCODE();
14372
433
  }
14373
14374
792
  ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14375
792
}
14376
14377
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14378
27.2k
{
14379
27.2k
  USE_OPLINE
14380
27.2k
  zval *op1, *op2;
14381
27.2k
  double d1, d2;
14382
14383
27.2k
  op1 = EX_VAR(opline->op1.var);
14384
27.2k
  op2 = EX_VAR(opline->op2.var);
14385
27.2k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14386
    /* pass */
14387
27.2k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14388
2.19k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14389
1.48k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14390
357
is_smaller_true:
14391
357
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
14392
1.22k
      } else {
14393
1.47k
is_smaller_false:
14394
1.47k
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
14395
1.47k
      }
14396
1.48k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14397
97
      d1 = (double)Z_LVAL_P(op1);
14398
97
      d2 = Z_DVAL_P(op2);
14399
97
      goto is_smaller_double;
14400
97
    }
14401
25.0k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14402
346
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14403
220
      d1 = Z_DVAL_P(op1);
14404
220
      d2 = Z_DVAL_P(op2);
14405
344
is_smaller_double:
14406
344
      if (d1 < d2) {
14407
91
        goto is_smaller_true;
14408
253
      } else {
14409
253
        goto is_smaller_false;
14410
253
      }
14411
344
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14412
27
      d1 = Z_DVAL_P(op1);
14413
27
      d2 = (double)Z_LVAL_P(op2);
14414
27
      goto is_smaller_double;
14415
27
    }
14416
346
  }
14417
27.2k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14418
27.2k
}
14419
14420
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14421
249
{
14422
249
  USE_OPLINE
14423
249
  zval *op1, *op2;
14424
249
  double d1, d2;
14425
14426
249
  op1 = EX_VAR(opline->op1.var);
14427
249
  op2 = EX_VAR(opline->op2.var);
14428
249
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14429
    /* pass */
14430
249
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14431
35
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14432
3
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14433
4
is_smaller_true:
14434
4
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
14435
4
      } else {
14436
85
is_smaller_false:
14437
85
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
14438
85
      }
14439
32
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14440
20
      d1 = (double)Z_LVAL_P(op1);
14441
20
      d2 = Z_DVAL_P(op2);
14442
20
      goto is_smaller_double;
14443
20
    }
14444
214
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14445
75
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14446
48
      d1 = Z_DVAL_P(op1);
14447
48
      d2 = Z_DVAL_P(op2);
14448
86
is_smaller_double:
14449
86
      if (d1 < d2) {
14450
2
        goto is_smaller_true;
14451
84
      } else {
14452
84
        goto is_smaller_false;
14453
84
      }
14454
86
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14455
18
      d1 = Z_DVAL_P(op1);
14456
18
      d2 = (double)Z_LVAL_P(op2);
14457
18
      goto is_smaller_double;
14458
18
    }
14459
75
  }
14460
249
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14461
249
}
14462
14463
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14464
10.7k
{
14465
10.7k
  USE_OPLINE
14466
10.7k
  zval *op1, *op2;
14467
10.7k
  double d1, d2;
14468
14469
10.7k
  op1 = EX_VAR(opline->op1.var);
14470
10.7k
  op2 = EX_VAR(opline->op2.var);
14471
10.7k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14472
    /* pass */
14473
10.7k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14474
9.71k
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14475
9.45k
      if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14476
9.24k
is_smaller_true:
14477
9.24k
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14478
9.24k
      } else {
14479
549
is_smaller_false:
14480
549
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14481
549
      }
14482
9.45k
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14483
174
      d1 = (double)Z_LVAL_P(op1);
14484
174
      d2 = Z_DVAL_P(op2);
14485
174
      goto is_smaller_double;
14486
174
    }
14487
9.71k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14488
163
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14489
26
      d1 = Z_DVAL_P(op1);
14490
26
      d2 = Z_DVAL_P(op2);
14491
337
is_smaller_double:
14492
337
      if (d1 < d2) {
14493
290
        goto is_smaller_true;
14494
290
      } else {
14495
47
        goto is_smaller_false;
14496
47
      }
14497
337
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14498
137
      d1 = Z_DVAL_P(op1);
14499
137
      d2 = (double)Z_LVAL_P(op2);
14500
137
      goto is_smaller_double;
14501
137
    }
14502
163
  }
14503
10.7k
  ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14504
10.7k
}
14505
14506
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14507
18.0k
{
14508
18.0k
  USE_OPLINE
14509
18.0k
  zval *op1, *op2;
14510
18.0k
  double d1, d2;
14511
14512
18.0k
  op1 = EX_VAR(opline->op1.var);
14513
18.0k
  op2 = EX_VAR(opline->op2.var);
14514
18.0k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14515
    /* pass */
14516
18.0k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14517
114
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14518
76
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14519
30
is_smaller_or_equal_true:
14520
30
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
14521
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
14522
0
        ZEND_VM_NEXT_OPCODE();
14523
64
      } else {
14524
176
is_smaller_or_equal_false:
14525
176
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
14526
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
14527
0
        ZEND_VM_NEXT_OPCODE();
14528
0
      }
14529
76
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14530
32
      d1 = (double)Z_LVAL_P(op1);
14531
32
      d2 = Z_DVAL_P(op2);
14532
32
      goto is_smaller_or_equal_double;
14533
32
    }
14534
17.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14535
102
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14536
74
      d1 = Z_DVAL_P(op1);
14537
74
      d2 = Z_DVAL_P(op2);
14538
130
is_smaller_or_equal_double:
14539
130
      if (d1 <= d2) {
14540
18
        goto is_smaller_or_equal_true;
14541
112
      } else {
14542
112
        goto is_smaller_or_equal_false;
14543
112
      }
14544
130
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14545
24
      d1 = Z_DVAL_P(op1);
14546
24
      d2 = (double)Z_LVAL_P(op2);
14547
24
      goto is_smaller_or_equal_double;
14548
24
    }
14549
102
  }
14550
18.0k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14551
18.0k
}
14552
14553
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14554
601
{
14555
601
  USE_OPLINE
14556
601
  zval *op1, *op2;
14557
601
  double d1, d2;
14558
14559
601
  op1 = EX_VAR(opline->op1.var);
14560
601
  op2 = EX_VAR(opline->op2.var);
14561
601
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14562
    /* pass */
14563
601
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14564
306
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14565
260
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14566
168
is_smaller_or_equal_true:
14567
168
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
14568
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
14569
0
        ZEND_VM_NEXT_OPCODE();
14570
106
      } else {
14571
175
is_smaller_or_equal_false:
14572
175
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
14573
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
14574
0
        ZEND_VM_NEXT_OPCODE();
14575
0
      }
14576
260
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14577
18
      d1 = (double)Z_LVAL_P(op1);
14578
18
      d2 = Z_DVAL_P(op2);
14579
18
      goto is_smaller_or_equal_double;
14580
18
    }
14581
306
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14582
73
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14583
47
      d1 = Z_DVAL_P(op1);
14584
47
      d2 = Z_DVAL_P(op2);
14585
83
is_smaller_or_equal_double:
14586
83
      if (d1 <= d2) {
14587
14
        goto is_smaller_or_equal_true;
14588
69
      } else {
14589
69
        goto is_smaller_or_equal_false;
14590
69
      }
14591
83
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14592
18
      d1 = Z_DVAL_P(op1);
14593
18
      d2 = (double)Z_LVAL_P(op2);
14594
18
      goto is_smaller_or_equal_double;
14595
18
    }
14596
73
  }
14597
601
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14598
601
}
14599
14600
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14601
1.82k
{
14602
1.82k
  USE_OPLINE
14603
1.82k
  zval *op1, *op2;
14604
1.82k
  double d1, d2;
14605
14606
1.82k
  op1 = EX_VAR(opline->op1.var);
14607
1.82k
  op2 = EX_VAR(opline->op2.var);
14608
1.82k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14609
    /* pass */
14610
1.82k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14611
951
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14612
615
      if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14613
756
is_smaller_or_equal_true:
14614
756
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14615
0
        ZVAL_TRUE(EX_VAR(opline->result.var));
14616
0
        ZEND_VM_NEXT_OPCODE();
14617
180
      } else {
14618
230
is_smaller_or_equal_false:
14619
230
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14620
0
        ZVAL_FALSE(EX_VAR(opline->result.var));
14621
0
        ZEND_VM_NEXT_OPCODE();
14622
0
      }
14623
615
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14624
336
      d1 = (double)Z_LVAL_P(op1);
14625
336
      d2 = Z_DVAL_P(op2);
14626
336
      goto is_smaller_or_equal_double;
14627
336
    }
14628
951
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14629
37
    if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14630
24
      d1 = Z_DVAL_P(op1);
14631
24
      d2 = Z_DVAL_P(op2);
14632
371
is_smaller_or_equal_double:
14633
371
      if (d1 <= d2) {
14634
321
        goto is_smaller_or_equal_true;
14635
321
      } else {
14636
50
        goto is_smaller_or_equal_false;
14637
50
      }
14638
371
    } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14639
11
      d1 = Z_DVAL_P(op1);
14640
11
      d2 = (double)Z_LVAL_P(op2);
14641
11
      goto is_smaller_or_equal_double;
14642
11
    }
14643
37
  }
14644
1.82k
  ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14645
1.82k
}
14646
14647
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14648
2.15k
{
14649
2.15k
  USE_OPLINE
14650
2.15k
  zval *op1, *op2;
14651
14652
2.15k
  op1 = EX_VAR(opline->op1.var);
14653
2.15k
  op2 = EX_VAR(opline->op2.var);
14654
2.15k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14655
    /* pass */
14656
2.15k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14657
2.15k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14658
387
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
14659
387
    ZEND_VM_NEXT_OPCODE();
14660
387
  }
14661
14662
2.15k
  ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14663
2.15k
}
14664
14665
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14666
116k
{
14667
116k
  USE_OPLINE
14668
116k
  zval *op1, *op2;
14669
14670
116k
  op1 = EX_VAR(opline->op1.var);
14671
116k
  op2 = EX_VAR(opline->op2.var);
14672
116k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14673
    /* pass */
14674
116k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14675
116k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14676
6.31k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
14677
6.31k
    ZEND_VM_NEXT_OPCODE();
14678
6.31k
  }
14679
14680
116k
  ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14681
116k
}
14682
14683
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14684
57.2k
{
14685
57.2k
  USE_OPLINE
14686
57.2k
  zval *op1, *op2;
14687
14688
57.2k
  op1 = EX_VAR(opline->op1.var);
14689
57.2k
  op2 = EX_VAR(opline->op2.var);
14690
57.2k
  if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14691
    /* pass */
14692
57.2k
  } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14693
57.2k
      && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14694
109
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
14695
109
    ZEND_VM_NEXT_OPCODE();
14696
109
  }
14697
14698
57.2k
  ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
14699
57.2k
}
14700
14701
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14702
0
{
14703
0
  USE_OPLINE
14704
0
  zval *op1, *op2, *result;
14705
14706
0
  op1 = EX_VAR(opline->op1.var);
14707
0
  op2 = EX_VAR(opline->op2.var);
14708
0
  result = EX_VAR(opline->result.var);
14709
0
  ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
14710
0
  ZEND_VM_NEXT_OPCODE();
14711
0
}
14712
14713
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14714
1.94k
{
14715
1.94k
  USE_OPLINE
14716
1.94k
  zval *op1, *op2, *result;
14717
14718
1.94k
  op1 = EX_VAR(opline->op1.var);
14719
1.94k
  op2 = EX_VAR(opline->op2.var);
14720
1.94k
  result = EX_VAR(opline->result.var);
14721
1.94k
  fast_long_add_function(result, op1, op2);
14722
1.94k
  ZEND_VM_NEXT_OPCODE();
14723
1.94k
}
14724
14725
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14726
86
{
14727
86
  USE_OPLINE
14728
86
  zval *op1, *op2, *result;
14729
14730
86
  op1 = EX_VAR(opline->op1.var);
14731
86
  op2 = EX_VAR(opline->op2.var);
14732
86
  result = EX_VAR(opline->result.var);
14733
86
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
14734
86
  ZEND_VM_NEXT_OPCODE();
14735
86
}
14736
14737
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14738
0
{
14739
0
  USE_OPLINE
14740
0
  zval *op1, *op2, *result;
14741
14742
0
  op1 = EX_VAR(opline->op1.var);
14743
0
  op2 = EX_VAR(opline->op2.var);
14744
0
  result = EX_VAR(opline->result.var);
14745
0
  ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
14746
0
  ZEND_VM_NEXT_OPCODE();
14747
0
}
14748
14749
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14750
5
{
14751
5
  USE_OPLINE
14752
5
  zval *op1, *op2, *result;
14753
14754
5
  op1 = EX_VAR(opline->op1.var);
14755
5
  op2 = EX_VAR(opline->op2.var);
14756
5
  result = EX_VAR(opline->result.var);
14757
5
  fast_long_sub_function(result, op1, op2);
14758
5
  ZEND_VM_NEXT_OPCODE();
14759
5
}
14760
14761
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14762
0
{
14763
0
  USE_OPLINE
14764
0
  zval *op1, *op2, *result;
14765
14766
0
  op1 = EX_VAR(opline->op1.var);
14767
0
  op2 = EX_VAR(opline->op2.var);
14768
0
  result = EX_VAR(opline->result.var);
14769
0
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
14770
0
  ZEND_VM_NEXT_OPCODE();
14771
0
}
14772
14773
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14774
0
{
14775
0
  USE_OPLINE
14776
0
  zval *op1, *op2, *result;
14777
14778
0
  op1 = EX_VAR(opline->op1.var);
14779
0
  op2 = EX_VAR(opline->op2.var);
14780
0
  result = EX_VAR(opline->result.var);
14781
0
  ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
14782
0
  ZEND_VM_NEXT_OPCODE();
14783
0
}
14784
14785
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14786
92
{
14787
92
  USE_OPLINE
14788
92
  zval *op1, *op2, *result;
14789
92
  zend_long overflow;
14790
14791
92
  op1 = EX_VAR(opline->op1.var);
14792
92
  op2 = EX_VAR(opline->op2.var);
14793
92
  result = EX_VAR(opline->result.var);
14794
92
  ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14795
92
  Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14796
92
  ZEND_VM_NEXT_OPCODE();
14797
92
}
14798
14799
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14800
0
{
14801
0
  USE_OPLINE
14802
0
  zval *op1, *op2, *result;
14803
14804
0
  op1 = EX_VAR(opline->op1.var);
14805
0
  op2 = EX_VAR(opline->op2.var);
14806
0
  result = EX_VAR(opline->result.var);
14807
0
  ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
14808
0
  ZEND_VM_NEXT_OPCODE();
14809
0
}
14810
14811
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14812
0
{
14813
0
  USE_OPLINE
14814
0
  zval *op1, *op2;
14815
0
  bool result;
14816
14817
0
  op1 = EX_VAR(opline->op1.var);
14818
0
  op2 = EX_VAR(opline->op2.var);
14819
0
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14820
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14821
0
}
14822
14823
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14824
0
{
14825
0
  USE_OPLINE
14826
0
  zval *op1, *op2;
14827
0
  bool result;
14828
14829
0
  op1 = EX_VAR(opline->op1.var);
14830
0
  op2 = EX_VAR(opline->op2.var);
14831
0
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14832
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14833
0
}
14834
14835
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14836
0
{
14837
0
  USE_OPLINE
14838
0
  zval *op1, *op2;
14839
0
  bool result;
14840
14841
0
  op1 = EX_VAR(opline->op1.var);
14842
0
  op2 = EX_VAR(opline->op2.var);
14843
0
  result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14844
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14845
0
}
14846
14847
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14848
127
{
14849
127
  USE_OPLINE
14850
127
  zval *op1, *op2;
14851
127
  bool result;
14852
14853
127
  op1 = EX_VAR(opline->op1.var);
14854
127
  op2 = EX_VAR(opline->op2.var);
14855
127
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14856
127
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14857
127
}
14858
14859
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14860
74
{
14861
74
  USE_OPLINE
14862
74
  zval *op1, *op2;
14863
74
  bool result;
14864
14865
74
  op1 = EX_VAR(opline->op1.var);
14866
74
  op2 = EX_VAR(opline->op2.var);
14867
74
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14868
74
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14869
74
}
14870
14871
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14872
70
{
14873
70
  USE_OPLINE
14874
70
  zval *op1, *op2;
14875
70
  bool result;
14876
14877
70
  op1 = EX_VAR(opline->op1.var);
14878
70
  op2 = EX_VAR(opline->op2.var);
14879
70
  result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14880
70
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14881
70
}
14882
14883
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14884
0
{
14885
0
  USE_OPLINE
14886
0
  zval *op1, *op2;
14887
0
  bool result;
14888
14889
0
  op1 = EX_VAR(opline->op1.var);
14890
0
  op2 = EX_VAR(opline->op2.var);
14891
0
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14892
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14893
0
}
14894
14895
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14896
0
{
14897
0
  USE_OPLINE
14898
0
  zval *op1, *op2;
14899
0
  bool result;
14900
14901
0
  op1 = EX_VAR(opline->op1.var);
14902
0
  op2 = EX_VAR(opline->op2.var);
14903
0
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14904
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14905
0
}
14906
14907
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14908
15
{
14909
15
  USE_OPLINE
14910
15
  zval *op1, *op2;
14911
15
  bool result;
14912
14913
15
  op1 = EX_VAR(opline->op1.var);
14914
15
  op2 = EX_VAR(opline->op2.var);
14915
15
  result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14916
15
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14917
15
}
14918
14919
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14920
163
{
14921
163
  USE_OPLINE
14922
163
  zval *op1, *op2;
14923
163
  bool result;
14924
14925
163
  op1 = EX_VAR(opline->op1.var);
14926
163
  op2 = EX_VAR(opline->op2.var);
14927
163
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14928
163
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14929
163
}
14930
14931
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14932
62
{
14933
62
  USE_OPLINE
14934
62
  zval *op1, *op2;
14935
62
  bool result;
14936
14937
62
  op1 = EX_VAR(opline->op1.var);
14938
62
  op2 = EX_VAR(opline->op2.var);
14939
62
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14940
62
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14941
62
}
14942
14943
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14944
64
{
14945
64
  USE_OPLINE
14946
64
  zval *op1, *op2;
14947
64
  bool result;
14948
14949
64
  op1 = EX_VAR(opline->op1.var);
14950
64
  op2 = EX_VAR(opline->op2.var);
14951
64
  result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14952
64
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14953
64
}
14954
14955
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14956
68
{
14957
68
  USE_OPLINE
14958
68
  zval *op1, *op2;
14959
68
  bool result;
14960
14961
68
  op1 = EX_VAR(opline->op1.var);
14962
68
  op2 = EX_VAR(opline->op2.var);
14963
68
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14964
68
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
14965
68
}
14966
14967
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14968
0
{
14969
0
  USE_OPLINE
14970
0
  zval *op1, *op2;
14971
0
  bool result;
14972
14973
0
  op1 = EX_VAR(opline->op1.var);
14974
0
  op2 = EX_VAR(opline->op2.var);
14975
0
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14976
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14977
0
}
14978
14979
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14980
1.36k
{
14981
1.36k
  USE_OPLINE
14982
1.36k
  zval *op1, *op2;
14983
1.36k
  bool result;
14984
14985
1.36k
  op1 = EX_VAR(opline->op1.var);
14986
1.36k
  op2 = EX_VAR(opline->op2.var);
14987
1.36k
  result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14988
1.36k
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14989
1.36k
}
14990
14991
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14992
2
{
14993
2
  USE_OPLINE
14994
2
  zval *op1, *op2;
14995
2
  bool result;
14996
14997
2
  op1 = EX_VAR(opline->op1.var);
14998
2
  op2 = EX_VAR(opline->op2.var);
14999
2
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
15000
2
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
15001
2
}
15002
15003
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15004
0
{
15005
0
  USE_OPLINE
15006
0
  zval *op1, *op2;
15007
0
  bool result;
15008
15009
0
  op1 = EX_VAR(opline->op1.var);
15010
0
  op2 = EX_VAR(opline->op2.var);
15011
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
15012
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
15013
0
}
15014
15015
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15016
0
{
15017
0
  USE_OPLINE
15018
0
  zval *op1, *op2;
15019
0
  bool result;
15020
15021
0
  op1 = EX_VAR(opline->op1.var);
15022
0
  op2 = EX_VAR(opline->op2.var);
15023
0
  result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
15024
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
15025
0
}
15026
15027
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15028
0
{
15029
0
  USE_OPLINE
15030
0
  zval *op1, *op2;
15031
0
  bool result;
15032
15033
0
  op1 = EX_VAR(opline->op1.var);
15034
0
  op2 = EX_VAR(opline->op2.var);
15035
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
15036
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
15037
0
}
15038
15039
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)
15040
0
{
15041
0
  USE_OPLINE
15042
0
  zval *op1, *op2;
15043
0
  bool result;
15044
15045
0
  op1 = EX_VAR(opline->op1.var);
15046
0
  op2 = EX_VAR(opline->op2.var);
15047
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
15048
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
15049
0
}
15050
15051
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)
15052
0
{
15053
0
  USE_OPLINE
15054
0
  zval *op1, *op2;
15055
0
  bool result;
15056
15057
0
  op1 = EX_VAR(opline->op1.var);
15058
0
  op2 = EX_VAR(opline->op2.var);
15059
0
  result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
15060
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
15061
0
}
15062
15063
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15064
0
{
15065
0
  USE_OPLINE
15066
0
  zval *op1, *op2;
15067
0
  bool result;
15068
15069
0
  op1 = EX_VAR(opline->op1.var);
15070
0
  op2 = EX_VAR(opline->op2.var);
15071
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
15072
0
  ZEND_VM_SMART_BRANCH_NONE(result, 0);
15073
0
}
15074
15075
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)
15076
0
{
15077
0
  USE_OPLINE
15078
0
  zval *op1, *op2;
15079
0
  bool result;
15080
15081
0
  op1 = EX_VAR(opline->op1.var);
15082
0
  op2 = EX_VAR(opline->op2.var);
15083
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
15084
0
  ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
15085
0
}
15086
15087
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)
15088
0
{
15089
0
  USE_OPLINE
15090
0
  zval *op1, *op2;
15091
0
  bool result;
15092
15093
0
  op1 = EX_VAR(opline->op1.var);
15094
0
  op2 = EX_VAR(opline->op2.var);
15095
0
  result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
15096
0
  ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
15097
0
}
15098
15099
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15100
23
{
15101
23
  USE_OPLINE
15102
23
  zval *container;
15103
15104
23
  SAVE_OPLINE();
15105
23
  container = EX_VAR(opline->op1.var);
15106
23
  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);
15107
23
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
15108
23
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15109
23
}
15110
15111
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15112
120
{
15113
120
  USE_OPLINE
15114
120
  zval *op;
15115
15116
120
  SAVE_OPLINE();
15117
120
  op = EX_VAR(opline->op1.var);
15118
120
  zend_match_unhandled_error(op);
15119
120
  HANDLE_EXCEPTION();
15120
120
}
15121
15122
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15123
27
{
15124
27
  USE_OPLINE
15125
27
  zval *container;
15126
15127
27
  SAVE_OPLINE();
15128
27
  container = EX_VAR(opline->op1.var);
15129
27
  zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
15130
15131
27
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15132
27
}
15133
15134
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15135
7.34k
{
15136
7.34k
  USE_OPLINE
15137
7.34k
  zval *val;
15138
15139
7.34k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15140
7.34k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15141
583
    ZVAL_FALSE(EX_VAR(opline->result.var));
15142
6.76k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15143
    /* The result and op1 can be the same cv zval */
15144
567
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
15145
567
    ZVAL_TRUE(EX_VAR(opline->result.var));
15146
567
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
15147
0
      SAVE_OPLINE();
15148
0
      ZVAL_UNDEFINED_OP1();
15149
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15150
0
    }
15151
6.19k
  } else {
15152
6.19k
    SAVE_OPLINE();
15153
6.19k
    ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
15154
6.19k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15155
6.19k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15156
6.19k
  }
15157
1.15k
  ZEND_VM_NEXT_OPCODE();
15158
1.15k
}
15159
15160
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15161
150k
{
15162
150k
  USE_OPLINE
15163
150k
  zval *z;
15164
15165
150k
  SAVE_OPLINE();
15166
150k
  z = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15167
15168
150k
  if (Z_TYPE_P(z) == IS_STRING) {
15169
149k
    zend_string *str = Z_STR_P(z);
15170
15171
149k
    if (ZSTR_LEN(str) != 0) {
15172
149k
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
15173
149k
    }
15174
149k
  } else {
15175
1.39k
    zend_string *str = zval_get_string_func(z);
15176
15177
1.39k
    if (ZSTR_LEN(str) != 0) {
15178
1.06k
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
15179
1.06k
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
15180
0
      ZVAL_UNDEFINED_OP1();
15181
0
    }
15182
1.39k
    zend_string_release_ex(str, 0);
15183
1.39k
  }
15184
15185
150k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15186
150k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15187
150k
}
15188
15189
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15190
2.16k
{
15191
2.16k
  USE_OPLINE
15192
2.16k
  zval *val;
15193
2.16k
  uint8_t op1_type;
15194
15195
2.16k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15196
15197
2.16k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15198
506
    ZEND_VM_NEXT_OPCODE();
15199
1.65k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15200
1.17k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15201
0
      SAVE_OPLINE();
15202
0
      ZVAL_UNDEFINED_OP1();
15203
0
      if (UNEXPECTED(EG(exception))) {
15204
0
        HANDLE_EXCEPTION();
15205
0
      }
15206
0
    }
15207
1.17k
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15208
1.17k
  }
15209
15210
2.16k
  SAVE_OPLINE();
15211
483
  op1_type = (IS_TMP_VAR|IS_VAR);
15212
483
  if (i_zend_is_true(val)) {
15213
290
    opline++;
15214
290
  } else {
15215
193
    opline = OP_JMP_ADDR(opline, opline->op2);
15216
193
  }
15217
483
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
15218
483
    zval_ptr_dtor_nogc(val);
15219
483
  }
15220
483
  ZEND_VM_JMP(opline);
15221
483
}
15222
15223
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15224
57.7k
{
15225
57.7k
  USE_OPLINE
15226
57.7k
  zval *val;
15227
57.7k
  uint8_t op1_type;
15228
15229
57.7k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15230
15231
57.7k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15232
2.84k
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15233
54.8k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15234
417
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15235
0
      SAVE_OPLINE();
15236
0
      ZVAL_UNDEFINED_OP1();
15237
0
      if (UNEXPECTED(EG(exception))) {
15238
0
        HANDLE_EXCEPTION();
15239
0
      }
15240
0
    }
15241
417
    ZEND_VM_NEXT_OPCODE();
15242
417
  }
15243
15244
57.7k
  SAVE_OPLINE();
15245
54.4k
  op1_type = (IS_TMP_VAR|IS_VAR);
15246
54.4k
  if (i_zend_is_true(val)) {
15247
53.0k
    opline = OP_JMP_ADDR(opline, opline->op2);
15248
53.0k
  } else {
15249
1.40k
    opline++;
15250
1.40k
  }
15251
54.4k
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
15252
54.4k
    zval_ptr_dtor_nogc(val);
15253
54.4k
  }
15254
54.4k
  ZEND_VM_JMP(opline);
15255
54.4k
}
15256
15257
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15258
1.56k
{
15259
1.56k
  USE_OPLINE
15260
1.56k
  zval *val;
15261
1.56k
  bool ret;
15262
15263
1.56k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15264
15265
1.56k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15266
330
    ZVAL_TRUE(EX_VAR(opline->result.var));
15267
330
    ZEND_VM_NEXT_OPCODE();
15268
1.23k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15269
220
    ZVAL_FALSE(EX_VAR(opline->result.var));
15270
220
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15271
0
      SAVE_OPLINE();
15272
0
      ZVAL_UNDEFINED_OP1();
15273
0
      if (UNEXPECTED(EG(exception))) {
15274
0
        HANDLE_EXCEPTION();
15275
0
      }
15276
0
    }
15277
220
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15278
220
  }
15279
15280
1.56k
  SAVE_OPLINE();
15281
1.01k
  ret = i_zend_is_true(val);
15282
1.01k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15283
1.01k
  if (ret) {
15284
922
    ZVAL_TRUE(EX_VAR(opline->result.var));
15285
922
    opline++;
15286
922
  } else {
15287
93
    ZVAL_FALSE(EX_VAR(opline->result.var));
15288
93
    opline = OP_JMP_ADDR(opline, opline->op2);
15289
93
  }
15290
1.01k
  ZEND_VM_JMP(opline);
15291
1.01k
}
15292
15293
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15294
1.79k
{
15295
1.79k
  USE_OPLINE
15296
1.79k
  zval *val;
15297
1.79k
  bool ret;
15298
15299
1.79k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15300
15301
1.79k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15302
386
    ZVAL_TRUE(EX_VAR(opline->result.var));
15303
386
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15304
1.40k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15305
316
    ZVAL_FALSE(EX_VAR(opline->result.var));
15306
316
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15307
0
      SAVE_OPLINE();
15308
0
      ZVAL_UNDEFINED_OP1();
15309
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15310
316
    } else {
15311
316
      ZEND_VM_NEXT_OPCODE();
15312
316
    }
15313
316
  }
15314
15315
1.79k
  SAVE_OPLINE();
15316
1.09k
  ret = i_zend_is_true(val);
15317
1.09k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15318
1.09k
  if (ret) {
15319
1.06k
    ZVAL_TRUE(EX_VAR(opline->result.var));
15320
1.06k
    opline = OP_JMP_ADDR(opline, opline->op2);
15321
1.06k
  } else {
15322
24
    ZVAL_FALSE(EX_VAR(opline->result.var));
15323
24
    opline++;
15324
24
  }
15325
1.09k
  ZEND_VM_JMP(opline);
15326
1.09k
}
15327
15328
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15329
54.2k
{
15330
54.2k
  USE_OPLINE
15331
15332
54.2k
  SAVE_OPLINE();
15333
54.2k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15334
54.2k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15335
54.2k
}
15336
15337
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15338
13.6k
{
15339
13.6k
  zval *var;
15340
13.6k
  USE_OPLINE
15341
15342
13.6k
  var = EX_VAR(opline->op1.var);
15343
13.6k
  if (Z_TYPE_P(var) != IS_ARRAY) {
15344
3.89k
    SAVE_OPLINE();
15345
3.89k
    if (Z_FE_ITER_P(var) != (uint32_t)-1) {
15346
1.11k
      zend_hash_iterator_del(Z_FE_ITER_P(var));
15347
1.11k
    }
15348
3.89k
    zval_ptr_dtor_nogc(var);
15349
3.89k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15350
3.89k
  }
15351
15352
  /* This is freeing an array. Use an inlined version of zval_ptr_dtor_nogc. */
15353
  /* 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) */
15354
9.78k
  if (Z_REFCOUNTED_P(var) && !Z_DELREF_P(var)) {
15355
460
    SAVE_OPLINE();
15356
460
    rc_dtor_func(Z_COUNTED_P(var));
15357
460
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15358
460
  }
15359
9.32k
  ZEND_VM_NEXT_OPCODE();
15360
9.32k
}
15361
15362
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15363
2.65k
{
15364
2.65k
  USE_OPLINE
15365
2.65k
  zval *value;
15366
15367
2.65k
  SAVE_OPLINE();
15368
2.65k
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15369
15370
2.65k
  do {
15371
2.65k
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
15372
4
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
15373
0
        value = Z_REFVAL_P(value);
15374
0
        if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
15375
0
          break;
15376
0
        }
15377
0
      }
15378
4
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15379
0
        ZVAL_UNDEFINED_OP1();
15380
0
        if (UNEXPECTED(EG(exception) != NULL)) {
15381
0
          HANDLE_EXCEPTION();
15382
0
        }
15383
0
      }
15384
4
      zend_throw_error(NULL, "Can only throw objects");
15385
4
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15386
4
      HANDLE_EXCEPTION();
15387
4
    }
15388
2.65k
  } while (0);
15389
15390
2.65k
  zend_exception_save();
15391
2.65k
  Z_TRY_ADDREF_P(value);
15392
2.65k
  zend_throw_exception_object(value);
15393
2.65k
  zend_exception_restore();
15394
2.65k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15395
2.65k
  HANDLE_EXCEPTION();
15396
2.65k
}
15397
15398
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15399
2.82k
{
15400
2.82k
  USE_OPLINE
15401
2.82k
  zval *val;
15402
15403
2.82k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15404
2.82k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15405
67
    ZVAL_TRUE(EX_VAR(opline->result.var));
15406
2.75k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15407
    /* The result and op1 can be the same cv zval */
15408
142
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
15409
142
    ZVAL_FALSE(EX_VAR(opline->result.var));
15410
142
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
15411
0
      SAVE_OPLINE();
15412
0
      ZVAL_UNDEFINED_OP1();
15413
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15414
0
    }
15415
2.61k
  } else {
15416
2.61k
    SAVE_OPLINE();
15417
2.61k
    ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
15418
2.61k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15419
2.61k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15420
2.61k
  }
15421
209
  ZEND_VM_NEXT_OPCODE();
15422
209
}
15423
15424
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15425
247
{
15426
247
  USE_OPLINE
15427
247
  zval *obj;
15428
247
  zend_object *zobj;
15429
247
  zend_class_entry *ce, *scope;
15430
247
  zend_function *clone;
15431
247
  zend_object_clone_obj_t clone_call;
15432
15433
247
  SAVE_OPLINE();
15434
247
  obj = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15435
15436
  /* ZEND_CLONE also exists as the clone() function and both implementations must be kept in sync.
15437
   * The OPcode intentionally does not support a clone-with property list to keep it simple. */
15438
15439
247
  do {
15440
247
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
15441
247
        ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
15442
7
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
15443
0
        obj = Z_REFVAL_P(obj);
15444
0
        if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
15445
0
          break;
15446
0
        }
15447
0
      }
15448
7
      ZVAL_UNDEF(EX_VAR(opline->result.var));
15449
7
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
15450
0
        ZVAL_UNDEFINED_OP1();
15451
0
        if (UNEXPECTED(EG(exception) != NULL)) {
15452
0
          HANDLE_EXCEPTION();
15453
0
        }
15454
0
      }
15455
7
      zend_type_error("clone(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(obj));
15456
7
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15457
7
      HANDLE_EXCEPTION();
15458
7
    }
15459
247
  } while (0);
15460
15461
240
  zobj = Z_OBJ_P(obj);
15462
240
  ce = zobj->ce;
15463
240
  clone = ce->clone;
15464
240
  clone_call = zobj->handlers->clone_obj;
15465
240
  if (UNEXPECTED(clone_call == NULL)) {
15466
5
    zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
15467
5
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15468
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
15469
5
    HANDLE_EXCEPTION();
15470
5
  }
15471
15472
235
  if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
15473
10
    scope = EX(func)->op_array.scope;
15474
10
    ZEND_ASSERT(!(clone->common.fn_flags & ZEND_ACC_PUBLIC));
15475
10
    if (!zend_check_method_accessible(clone, scope)) {
15476
0
      zend_bad_method_call(clone, clone->common.function_name, scope);
15477
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15478
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
15479
0
      HANDLE_EXCEPTION();
15480
0
    }
15481
10
  }
15482
15483
235
  ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
15484
15485
235
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15486
235
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15487
235
}
15488
15489
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15490
1.01k
{
15491
1.01k
  USE_OPLINE
15492
1.01k
  zend_op_array *new_op_array;
15493
1.01k
  zval *inc_filename;
15494
15495
1.01k
  SAVE_OPLINE();
15496
1.01k
  inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15497
1.01k
  new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
15498
1.01k
  if (UNEXPECTED(EG(exception) != NULL)) {
15499
49
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15500
49
    if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
15501
0
      destroy_op_array(new_op_array);
15502
0
      efree_size(new_op_array, sizeof(zend_op_array));
15503
0
    }
15504
49
    UNDEF_RESULT();
15505
49
    HANDLE_EXCEPTION();
15506
966
  } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
15507
0
    if (RETURN_VALUE_USED(opline)) {
15508
0
      ZVAL_TRUE(EX_VAR(opline->result.var));
15509
0
    }
15510
966
  } else if (UNEXPECTED(new_op_array == NULL)) {
15511
23
    if (RETURN_VALUE_USED(opline)) {
15512
0
      ZVAL_FALSE(EX_VAR(opline->result.var));
15513
0
    }
15514
943
  } else if (new_op_array->last == 1
15515
943
      && new_op_array->opcodes[0].opcode == ZEND_RETURN
15516
943
      && new_op_array->opcodes[0].op1_type == IS_CONST
15517
943
      && EXPECTED(zend_execute_ex == execute_ex)) {
15518
384
    if (RETURN_VALUE_USED(opline)) {
15519
0
      const zend_op *op = new_op_array->opcodes;
15520
15521
0
      ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
15522
0
    }
15523
384
    zend_destroy_static_vars(new_op_array);
15524
384
    destroy_op_array(new_op_array);
15525
384
    efree_size(new_op_array, sizeof(zend_op_array));
15526
559
  } else {
15527
559
    zval *return_value = NULL;
15528
559
    zend_execute_data *call;
15529
559
    if (RETURN_VALUE_USED(opline)) {
15530
59
      return_value = EX_VAR(opline->result.var);
15531
59
    }
15532
15533
559
    new_op_array->scope = EX(func)->op_array.scope;
15534
15535
559
    call = zend_vm_stack_push_call_frame(
15536
559
      (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
15537
559
      (zend_function*)new_op_array, 0,
15538
559
      Z_PTR(EX(This)));
15539
15540
559
    if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
15541
384
      call->symbol_table = EX(symbol_table);
15542
384
    } else {
15543
175
      call->symbol_table = zend_rebuild_symbol_table();
15544
175
    }
15545
15546
559
    call->prev_execute_data = execute_data;
15547
559
    i_init_code_execute_data(call, new_op_array, return_value);
15548
15549
559
    if (EXPECTED(zend_execute_ex == execute_ex)) {
15550
71
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15551
71
      ZEND_VM_ENTER();
15552
488
    } else {
15553
488
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
15554
488
      zend_execute_ex(call);
15555
488
      zend_vm_stack_free_call_frame(call);
15556
488
    }
15557
15558
488
    zend_destroy_static_vars(new_op_array);
15559
488
    destroy_op_array(new_op_array);
15560
488
    efree_size(new_op_array, sizeof(zend_op_array));
15561
488
    if (UNEXPECTED(EG(exception) != NULL)) {
15562
15
      zend_rethrow_exception(execute_data);
15563
15
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15564
15
      UNDEF_RESULT();
15565
15
      HANDLE_EXCEPTION();
15566
15
    }
15567
488
  }
15568
880
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15569
880
  ZEND_VM_NEXT_OPCODE();
15570
880
}
15571
15572
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15573
1.01k
{
15574
1.01k
  USE_OPLINE
15575
1.01k
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
15576
1.01k
  zval *val;
15577
15578
1.01k
  SAVE_OPLINE();
15579
1.01k
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15580
15581
1.01k
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
15582
10
    zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
15583
10
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15584
10
    UNDEF_RESULT();
15585
10
    HANDLE_EXCEPTION();
15586
10
  }
15587
15588
1.00k
yield_from_try_again:
15589
1.00k
  if (Z_TYPE_P(val) == IS_ARRAY) {
15590
38
    ZVAL_COPY_VALUE(&generator->values, val);
15591
38
    if (Z_OPT_REFCOUNTED_P(val)) {
15592
33
      Z_ADDREF_P(val);
15593
33
    }
15594
38
    Z_FE_POS(generator->values) = 0;
15595
38
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15596
967
  } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
15597
962
    zend_class_entry *ce = Z_OBJCE_P(val);
15598
962
    if (ce == zend_ce_generator) {
15599
889
      zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
15600
15601
889
      Z_ADDREF_P(val);
15602
889
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15603
15604
889
      if (UNEXPECTED(new_gen->execute_data == NULL)) {
15605
0
        zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
15606
0
        zval_ptr_dtor(val);
15607
0
        UNDEF_RESULT();
15608
0
        HANDLE_EXCEPTION();
15609
889
      } else if (Z_ISUNDEF(new_gen->retval)) {
15610
889
        if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
15611
5
          zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
15612
5
          zval_ptr_dtor(val);
15613
5
          UNDEF_RESULT();
15614
5
          HANDLE_EXCEPTION();
15615
884
        } else {
15616
884
          zend_generator_yield_from(generator, new_gen);
15617
884
        }
15618
889
      } else {
15619
0
        if (RETURN_VALUE_USED(opline)) {
15620
0
          ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
15621
0
        }
15622
0
        ZEND_VM_NEXT_OPCODE();
15623
0
      }
15624
889
    } else {
15625
73
      zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
15626
73
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15627
15628
73
      if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
15629
3
        if (!EG(exception)) {
15630
0
          zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
15631
0
        }
15632
3
        UNDEF_RESULT();
15633
3
        HANDLE_EXCEPTION();
15634
3
      }
15635
15636
70
      iter->index = 0;
15637
70
      if (iter->funcs->rewind) {
15638
70
        iter->funcs->rewind(iter);
15639
70
        if (UNEXPECTED(EG(exception) != NULL)) {
15640
2
          OBJ_RELEASE(&iter->std);
15641
2
          UNDEF_RESULT();
15642
2
          HANDLE_EXCEPTION();
15643
2
        }
15644
70
      }
15645
15646
68
      ZVAL_OBJ(&generator->values, &iter->std);
15647
68
    }
15648
962
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
15649
0
    val = Z_REFVAL_P(val);
15650
0
    goto yield_from_try_again;
15651
5
  } else {
15652
5
    zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
15653
5
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15654
5
    UNDEF_RESULT();
15655
5
    HANDLE_EXCEPTION();
15656
5
  }
15657
15658
  /* This is the default return value
15659
   * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
15660
990
  if (RETURN_VALUE_USED(opline)) {
15661
990
    ZVAL_NULL(EX_VAR(opline->result.var));
15662
990
  }
15663
15664
  /* This generator has no send target (though the generator we delegate to might have one) */
15665
990
  generator->send_target = NULL;
15666
15667
  /* The GOTO VM uses a local opline variable. We need to set the opline
15668
   * variable in execute_data so we don't resume at an old position. */
15669
990
  SAVE_OPLINE();
15670
15671
990
  ZEND_VM_RETURN();
15672
1.00k
}
15673
15674
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15675
70
{
15676
70
  USE_OPLINE
15677
70
  zval *value;
15678
15679
70
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15680
70
  if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15681
49
    ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15682
49
    if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15683
49
      zval_ptr_dtor_str(value);
15684
49
    }
15685
49
    ZEND_VM_NEXT_OPCODE();
15686
49
  } else {
15687
21
    bool strict;
15688
15689
21
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
15690
0
      value = Z_REFVAL_P(value);
15691
0
      if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15692
0
        ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15693
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15694
0
        ZEND_VM_NEXT_OPCODE();
15695
0
      }
15696
0
    }
15697
15698
21
    SAVE_OPLINE();
15699
21
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15700
0
      value = ZVAL_UNDEFINED_OP1();
15701
0
    }
15702
21
    strict = EX_USES_STRICT_TYPES();
15703
21
    do {
15704
21
      if (EXPECTED(!strict)) {
15705
21
        zend_string *str;
15706
21
        zval tmp;
15707
15708
21
        if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
15709
18
          zend_error(E_DEPRECATED,
15710
18
            "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
15711
18
          ZVAL_LONG(EX_VAR(opline->result.var), 0);
15712
18
          if (UNEXPECTED(EG(exception))) {
15713
0
            HANDLE_EXCEPTION();
15714
0
          }
15715
18
          break;
15716
18
        }
15717
15718
3
        ZVAL_COPY(&tmp, value);
15719
3
        if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
15720
3
          ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
15721
3
          zval_ptr_dtor(&tmp);
15722
3
          break;
15723
3
        }
15724
0
        zval_ptr_dtor(&tmp);
15725
0
      }
15726
0
      if (!EG(exception)) {
15727
0
        zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
15728
0
      }
15729
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
15730
0
    } while (0);
15731
21
  }
15732
21
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15733
21
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15734
21
}
15735
15736
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15737
2.48k
{
15738
2.48k
  USE_OPLINE
15739
2.48k
  zval *value;
15740
2.48k
  int result = 0;
15741
15742
2.48k
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15743
2.48k
  if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15744
770
type_check_resource:
15745
770
    if (opline->extended_value != MAY_BE_RESOURCE
15746
770
     || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
15747
770
      result = 1;
15748
770
    }
15749
1.71k
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
15750
0
    value = Z_REFVAL_P(value);
15751
0
    if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15752
0
      goto type_check_resource;
15753
0
    }
15754
1.71k
  } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15755
0
    result = ((1 << IS_NULL) & opline->extended_value) != 0;
15756
0
    SAVE_OPLINE();
15757
0
    ZVAL_UNDEFINED_OP1();
15758
0
    if (UNEXPECTED(EG(exception))) {
15759
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
15760
0
      HANDLE_EXCEPTION();
15761
0
    }
15762
0
  }
15763
2.48k
  if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15764
2.48k
    SAVE_OPLINE();
15765
2.48k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15766
2.48k
    ZEND_VM_SMART_BRANCH(result, 1);
15767
2.48k
  } else {
15768
0
    ZEND_VM_SMART_BRANCH(result, 0);
15769
0
  }
15770
2.48k
}
15771
15772
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15773
38
{
15774
38
  uint32_t fetch_type;
15775
38
  zend_class_entry *called_scope, *scope;
15776
38
  USE_OPLINE
15777
15778
38
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
15779
38
    SAVE_OPLINE();
15780
38
    zval *op = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15781
38
    if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
15782
3
      ZVAL_DEREF(op);
15783
3
      if (Z_TYPE_P(op) != IS_OBJECT) {
15784
3
        zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
15785
3
        ZVAL_UNDEF(EX_VAR(opline->result.var));
15786
3
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15787
3
        HANDLE_EXCEPTION();
15788
3
      }
15789
3
    }
15790
15791
35
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
15792
35
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15793
35
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15794
35
  }
15795
15796
0
  fetch_type = opline->op1.num;
15797
0
  scope = EX(func)->op_array.scope;
15798
0
  if (UNEXPECTED(scope == NULL)) {
15799
0
    SAVE_OPLINE();
15800
0
    zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
15801
0
      fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
15802
0
      fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
15803
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
15804
0
    HANDLE_EXCEPTION();
15805
0
  }
15806
15807
0
  switch (fetch_type) {
15808
0
    case ZEND_FETCH_CLASS_SELF:
15809
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
15810
0
      break;
15811
0
    case ZEND_FETCH_CLASS_PARENT:
15812
0
      if (UNEXPECTED(scope->parent == NULL)) {
15813
0
        SAVE_OPLINE();
15814
0
        zend_throw_error(NULL,
15815
0
          "Cannot use \"parent\" when current class scope has no parent");
15816
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
15817
0
        HANDLE_EXCEPTION();
15818
0
      }
15819
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
15820
0
      break;
15821
0
    case ZEND_FETCH_CLASS_STATIC:
15822
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
15823
0
        called_scope = Z_OBJCE(EX(This));
15824
0
      } else {
15825
0
        called_scope = Z_CE(EX(This));
15826
0
      }
15827
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
15828
0
      break;
15829
0
    EMPTY_SWITCH_DEFAULT_CASE()
15830
0
  }
15831
0
  ZEND_VM_NEXT_OPCODE();
15832
0
}
15833
15834
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15835
705
{
15836
705
  USE_OPLINE
15837
705
  zval *op1, *op2;
15838
15839
705
  SAVE_OPLINE();
15840
705
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15841
705
  op2 = RT_CONSTANT(opline, opline->op2);
15842
705
  div_function(EX_VAR(opline->result.var), op1, op2);
15843
705
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15844
15845
705
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15846
705
}
15847
15848
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15849
0
{
15850
0
  USE_OPLINE
15851
0
  zval *op1, *op2;
15852
15853
0
  SAVE_OPLINE();
15854
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15855
0
  op2 = RT_CONSTANT(opline, opline->op2);
15856
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
15857
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15858
15859
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15860
0
}
15861
15862
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15863
12.9k
{
15864
12.9k
  USE_OPLINE
15865
12.9k
  zval *op1, *op2;
15866
15867
12.9k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15868
12.9k
  op2 = RT_CONSTANT(opline, opline->op2);
15869
15870
12.9k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
15871
12.9k
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
15872
10.4k
    zend_string *op1_str = Z_STR_P(op1);
15873
10.4k
    zend_string *op2_str = Z_STR_P(op2);
15874
10.4k
    zend_string *str;
15875
10.4k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
15876
15877
10.4k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
15878
215
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
15879
215
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
15880
215
      } else {
15881
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
15882
0
      }
15883
215
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15884
215
        zend_string_release_ex(op1_str, 0);
15885
215
      }
15886
10.2k
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
15887
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
15888
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
15889
0
      } else {
15890
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
15891
0
      }
15892
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15893
0
        zend_string_release_ex(op2_str, 0);
15894
0
      }
15895
10.2k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
15896
10.2k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
15897
6.06k
      size_t len = ZSTR_LEN(op1_str);
15898
15899
6.06k
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
15900
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
15901
0
      }
15902
6.06k
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
15903
6.06k
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15904
6.06k
      GC_ADD_FLAGS(str, flags);
15905
6.06k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15906
6.06k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15907
0
        zend_string_release_ex(op2_str, 0);
15908
0
      }
15909
6.06k
    } else {
15910
4.14k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
15911
4.14k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
15912
4.14k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15913
4.14k
      GC_ADD_FLAGS(str, flags);
15914
4.14k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15915
4.14k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15916
4.14k
        zend_string_release_ex(op1_str, 0);
15917
4.14k
      }
15918
4.14k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15919
0
        zend_string_release_ex(op2_str, 0);
15920
0
      }
15921
4.14k
    }
15922
10.4k
    ZEND_VM_NEXT_OPCODE();
15923
10.4k
  } else {
15924
2.53k
    SAVE_OPLINE();
15925
15926
2.53k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
15927
0
      op1 = ZVAL_UNDEFINED_OP1();
15928
0
    }
15929
2.53k
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
15930
0
      op2 = ZVAL_UNDEFINED_OP2();
15931
0
    }
15932
2.53k
    concat_function(EX_VAR(opline->result.var), op1, op2);
15933
2.53k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15934
15935
2.53k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15936
2.53k
  }
15937
12.9k
}
15938
15939
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15940
270
{
15941
270
  USE_OPLINE
15942
270
  zval *op1, *op2;
15943
270
  double d1, d2;
15944
15945
270
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15946
270
  op2 = RT_CONSTANT(opline, opline->op2);
15947
270
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15948
    /* pass */
15949
270
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15950
37
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15951
37
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15952
74
is_equal_true:
15953
74
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
15954
74
      } else {
15955
173
is_equal_false:
15956
173
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
15957
173
      }
15958
37
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15959
0
      d1 = (double)Z_LVAL_P(op1);
15960
0
      d2 = Z_DVAL_P(op2);
15961
0
      goto is_equal_double;
15962
0
    }
15963
233
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15964
21
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15965
0
      d1 = Z_DVAL_P(op1);
15966
0
      d2 = Z_DVAL_P(op2);
15967
0
is_equal_double:
15968
0
      if (d1 == d2) {
15969
0
        goto is_equal_true;
15970
0
      } else {
15971
0
        goto is_equal_false;
15972
0
      }
15973
21
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15974
0
      d1 = Z_DVAL_P(op1);
15975
0
      d2 = (double)Z_LVAL_P(op2);
15976
0
      goto is_equal_double;
15977
0
    }
15978
212
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15979
210
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15980
210
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15981
210
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15982
210
        zval_ptr_dtor_str(op1);
15983
210
      }
15984
210
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15985
0
        zval_ptr_dtor_str(op2);
15986
0
      }
15987
210
      if (result) {
15988
37
        goto is_equal_true;
15989
173
      } else {
15990
173
        goto is_equal_false;
15991
173
      }
15992
210
    }
15993
210
  }
15994
270
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
15995
270
}
15996
15997
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15998
23.8k
{
15999
23.8k
  USE_OPLINE
16000
23.8k
  zval *op1, *op2;
16001
23.8k
  double d1, d2;
16002
16003
23.8k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16004
23.8k
  op2 = RT_CONSTANT(opline, opline->op2);
16005
23.8k
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16006
    /* pass */
16007
23.8k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16008
23.7k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16009
23.7k
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16010
23.6k
is_equal_true:
16011
23.6k
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
16012
23.6k
      } else {
16013
130
is_equal_false:
16014
130
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
16015
130
      }
16016
23.7k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16017
4
      d1 = (double)Z_LVAL_P(op1);
16018
4
      d2 = Z_DVAL_P(op2);
16019
4
      goto is_equal_double;
16020
4
    }
16021
23.7k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16022
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16023
0
      d1 = Z_DVAL_P(op1);
16024
0
      d2 = Z_DVAL_P(op2);
16025
4
is_equal_double:
16026
4
      if (d1 == d2) {
16027
0
        goto is_equal_true;
16028
4
      } else {
16029
4
        goto is_equal_false;
16030
4
      }
16031
4
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16032
0
      d1 = Z_DVAL_P(op1);
16033
0
      d2 = (double)Z_LVAL_P(op2);
16034
0
      goto is_equal_double;
16035
0
    }
16036
76
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16037
4
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16038
4
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16039
4
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16040
4
        zval_ptr_dtor_str(op1);
16041
4
      }
16042
4
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16043
0
        zval_ptr_dtor_str(op2);
16044
0
      }
16045
4
      if (result) {
16046
0
        goto is_equal_true;
16047
4
      } else {
16048
4
        goto is_equal_false;
16049
4
      }
16050
4
    }
16051
4
  }
16052
23.8k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16053
23.8k
}
16054
16055
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16056
535
{
16057
535
  USE_OPLINE
16058
535
  zval *op1, *op2;
16059
535
  double d1, d2;
16060
16061
535
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16062
535
  op2 = RT_CONSTANT(opline, opline->op2);
16063
535
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16064
    /* pass */
16065
535
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16066
251
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16067
68
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16068
36
is_equal_true:
16069
36
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
16070
36
      } else {
16071
215
is_equal_false:
16072
215
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
16073
215
      }
16074
183
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16075
183
      d1 = (double)Z_LVAL_P(op1);
16076
183
      d2 = Z_DVAL_P(op2);
16077
183
      goto is_equal_double;
16078
183
    }
16079
284
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16080
2
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16081
0
      d1 = Z_DVAL_P(op1);
16082
0
      d2 = Z_DVAL_P(op2);
16083
183
is_equal_double:
16084
183
      if (d1 == d2) {
16085
0
        goto is_equal_true;
16086
183
      } else {
16087
183
        goto is_equal_false;
16088
183
      }
16089
183
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16090
0
      d1 = Z_DVAL_P(op1);
16091
0
      d2 = (double)Z_LVAL_P(op2);
16092
0
      goto is_equal_double;
16093
0
    }
16094
282
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16095
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16096
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16097
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16098
0
        zval_ptr_dtor_str(op1);
16099
0
      }
16100
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16101
0
        zval_ptr_dtor_str(op2);
16102
0
      }
16103
0
      if (result) {
16104
0
        goto is_equal_true;
16105
0
      } else {
16106
0
        goto is_equal_false;
16107
0
      }
16108
0
    }
16109
0
  }
16110
535
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16111
535
}
16112
16113
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16114
1.01k
{
16115
1.01k
  USE_OPLINE
16116
1.01k
  zval *op1, *op2;
16117
1.01k
  double d1, d2;
16118
16119
1.01k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16120
1.01k
  op2 = RT_CONSTANT(opline, opline->op2);
16121
1.01k
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16122
    /* pass */
16123
1.01k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16124
377
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16125
350
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16126
291
is_not_equal_true:
16127
291
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
16128
291
      } else {
16129
93
is_not_equal_false:
16130
93
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
16131
93
      }
16132
350
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16133
0
      d1 = (double)Z_LVAL_P(op1);
16134
0
      d2 = Z_DVAL_P(op2);
16135
0
      goto is_not_equal_double;
16136
0
    }
16137
636
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16138
3
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16139
0
      d1 = Z_DVAL_P(op1);
16140
0
      d2 = Z_DVAL_P(op2);
16141
0
is_not_equal_double:
16142
0
      if (d1 != d2) {
16143
0
        goto is_not_equal_true;
16144
0
      } else {
16145
0
        goto is_not_equal_false;
16146
0
      }
16147
3
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16148
0
      d1 = Z_DVAL_P(op1);
16149
0
      d2 = (double)Z_LVAL_P(op2);
16150
0
      goto is_not_equal_double;
16151
0
    }
16152
633
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16153
231
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16154
34
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16155
34
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16156
34
        zval_ptr_dtor_str(op1);
16157
34
      }
16158
34
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16159
0
        zval_ptr_dtor_str(op2);
16160
0
      }
16161
34
      if (!result) {
16162
34
        goto is_not_equal_true;
16163
34
      } else {
16164
0
        goto is_not_equal_false;
16165
0
      }
16166
34
    }
16167
231
  }
16168
1.01k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16169
1.01k
}
16170
16171
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16172
16
{
16173
16
  USE_OPLINE
16174
16
  zval *op1, *op2;
16175
16
  double d1, d2;
16176
16177
16
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16178
16
  op2 = RT_CONSTANT(opline, opline->op2);
16179
16
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16180
    /* pass */
16181
16
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16182
12
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16183
12
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16184
7
is_not_equal_true:
16185
7
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
16186
7
      } else {
16187
5
is_not_equal_false:
16188
5
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
16189
5
      }
16190
12
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16191
0
      d1 = (double)Z_LVAL_P(op1);
16192
0
      d2 = Z_DVAL_P(op2);
16193
0
      goto is_not_equal_double;
16194
0
    }
16195
12
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16196
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16197
0
      d1 = Z_DVAL_P(op1);
16198
0
      d2 = Z_DVAL_P(op2);
16199
0
is_not_equal_double:
16200
0
      if (d1 != d2) {
16201
0
        goto is_not_equal_true;
16202
0
      } else {
16203
0
        goto is_not_equal_false;
16204
0
      }
16205
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16206
0
      d1 = Z_DVAL_P(op1);
16207
0
      d2 = (double)Z_LVAL_P(op2);
16208
0
      goto is_not_equal_double;
16209
0
    }
16210
4
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16211
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16212
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16213
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16214
0
        zval_ptr_dtor_str(op1);
16215
0
      }
16216
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16217
0
        zval_ptr_dtor_str(op2);
16218
0
      }
16219
0
      if (!result) {
16220
0
        goto is_not_equal_true;
16221
0
      } else {
16222
0
        goto is_not_equal_false;
16223
0
      }
16224
0
    }
16225
0
  }
16226
16
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16227
16
}
16228
16229
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16230
0
{
16231
0
  USE_OPLINE
16232
0
  zval *op1, *op2;
16233
0
  double d1, d2;
16234
16235
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16236
0
  op2 = RT_CONSTANT(opline, opline->op2);
16237
0
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16238
    /* pass */
16239
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16240
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16241
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16242
0
is_not_equal_true:
16243
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
16244
0
      } else {
16245
0
is_not_equal_false:
16246
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
16247
0
      }
16248
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16249
0
      d1 = (double)Z_LVAL_P(op1);
16250
0
      d2 = Z_DVAL_P(op2);
16251
0
      goto is_not_equal_double;
16252
0
    }
16253
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16254
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16255
0
      d1 = Z_DVAL_P(op1);
16256
0
      d2 = Z_DVAL_P(op2);
16257
0
is_not_equal_double:
16258
0
      if (d1 != d2) {
16259
0
        goto is_not_equal_true;
16260
0
      } else {
16261
0
        goto is_not_equal_false;
16262
0
      }
16263
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16264
0
      d1 = Z_DVAL_P(op1);
16265
0
      d2 = (double)Z_LVAL_P(op2);
16266
0
      goto is_not_equal_double;
16267
0
    }
16268
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16269
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16270
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16271
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16272
0
        zval_ptr_dtor_str(op1);
16273
0
      }
16274
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16275
0
        zval_ptr_dtor_str(op2);
16276
0
      }
16277
0
      if (!result) {
16278
0
        goto is_not_equal_true;
16279
0
      } else {
16280
0
        goto is_not_equal_false;
16281
0
      }
16282
0
    }
16283
0
  }
16284
0
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
16285
0
}
16286
16287
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16288
0
{
16289
0
  USE_OPLINE
16290
0
  zval *op1, *op2;
16291
16292
0
  SAVE_OPLINE();
16293
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16294
0
  op2 = RT_CONSTANT(opline, opline->op2);
16295
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
16296
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16297
16298
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16299
0
}
16300
16301
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16302
11.1k
{
16303
11.1k
  USE_OPLINE
16304
11.1k
  zval *op1, *op2;
16305
16306
11.1k
  SAVE_OPLINE();
16307
11.1k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16308
11.1k
  op2 = RT_CONSTANT(opline, opline->op2);
16309
11.1k
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
16310
11.1k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16311
16312
11.1k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16313
11.1k
}
16314
16315
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16316
2.26k
{
16317
2.26k
  USE_OPLINE
16318
2.26k
  zval *container, *dim, *value;
16319
16320
2.26k
  SAVE_OPLINE();
16321
2.26k
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16322
2.26k
  dim = RT_CONSTANT(opline, opline->op2);
16323
2.26k
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16324
2.26k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16325
1.26k
fetch_dim_r_array:
16326
1.26k
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
16327
1.26k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
16328
1.26k
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
16329
0
      container = Z_REFVAL_P(container);
16330
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16331
0
        goto fetch_dim_r_array;
16332
0
      } else {
16333
0
        goto fetch_dim_r_slow;
16334
0
      }
16335
1.00k
    } else {
16336
1.00k
fetch_dim_r_slow:
16337
1.00k
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
16338
3
        dim++;
16339
3
      }
16340
1.00k
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
16341
1.00k
    }
16342
2.26k
  } else {
16343
0
    zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16344
0
  }
16345
16346
2.26k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16347
2.26k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16348
2.26k
}
16349
16350
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16351
682
{
16352
682
  USE_OPLINE
16353
682
  zval *container;
16354
16355
682
  SAVE_OPLINE();
16356
682
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16357
682
  zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16358
16359
682
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16360
682
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16361
682
}
16362
16363
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16364
4.51k
{
16365
4.51k
  USE_OPLINE
16366
4.51k
  zval *container;
16367
4.51k
  void **cache_slot = NULL;
16368
16369
4.51k
  SAVE_OPLINE();
16370
4.51k
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16371
16372
4.51k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16373
4.51k
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16374
3.78k
    do {
16375
3.78k
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16376
0
        container = Z_REFVAL_P(container);
16377
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
16378
0
          break;
16379
0
        }
16380
0
      }
16381
3.78k
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
16382
0
        ZVAL_UNDEFINED_OP1();
16383
0
      }
16384
3.78k
      zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
16385
3.78k
      ZVAL_NULL(EX_VAR(opline->result.var));
16386
3.78k
      goto fetch_obj_r_finish;
16387
3.78k
    } while (0);
16388
3.78k
  }
16389
16390
  /* here we are sure we are dealing with an object */
16391
732
  do {
16392
732
    zend_object *zobj = Z_OBJ_P(container);
16393
732
    zend_string *name, *tmp_name;
16394
732
    zval *retval;
16395
16396
732
    if (IS_CONST == IS_CONST) {
16397
732
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
16398
16399
732
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
16400
73
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
16401
16402
73
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
16403
63
fetch_obj_r_simple:
16404
63
          retval = OBJ_PROP(zobj, prop_offset);
16405
63
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
16406
48
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16407
48
              goto fetch_obj_r_copy;
16408
48
            } else {
16409
0
fetch_obj_r_fast_copy:
16410
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16411
0
              ZEND_VM_NEXT_OPCODE();
16412
0
            }
16413
48
          }
16414
63
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
16415
5
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
16416
5
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
16417
0
            prop_offset = prop_info->offset;
16418
0
            goto fetch_obj_r_simple;
16419
5
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
16420
3
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
16421
3
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
16422
3
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
16423
16424
3
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16425
3
            if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
16426
0
              GC_ADDREF(zobj);
16427
0
            }
16428
3
            if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
16429
3
              call_info |= ZEND_CALL_RELEASE_THIS;
16430
3
            }
16431
3
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
16432
3
            call->prev_execute_data = execute_data;
16433
3
            call->call = NULL;
16434
3
            call->return_value = EX_VAR(opline->result.var);
16435
3
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
16436
16437
3
            execute_data = call;
16438
3
            EG(current_execute_data) = execute_data;
16439
3
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
16440
16441
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
16442
            opline = hook->op_array.opcodes;
16443
#else
16444
3
            EX(opline) = hook->op_array.opcodes;
16445
3
#endif
16446
3
            LOAD_OPLINE_EX();
16447
16448
16449
3
            ZEND_VM_ENTER_EX();
16450
3
          }
16451
          /* Fall through to read_property for hooks. */
16452
5
        } else if (EXPECTED(zobj->properties != NULL)) {
16453
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
16454
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16455
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
16456
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
16457
16458
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
16459
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
16460
16461
0
              if (EXPECTED(p->key == name) ||
16462
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
16463
0
                   EXPECTED(p->key != NULL) &&
16464
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
16465
0
                retval = &p->val;
16466
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16467
0
                  goto fetch_obj_r_copy;
16468
0
                } else {
16469
0
                  goto fetch_obj_r_fast_copy;
16470
0
                }
16471
0
              }
16472
0
            }
16473
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
16474
0
          }
16475
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
16476
0
          if (EXPECTED(retval)) {
16477
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
16478
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
16479
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16480
0
              goto fetch_obj_r_copy;
16481
0
            } else {
16482
0
              goto fetch_obj_r_fast_copy;
16483
0
            }
16484
0
          }
16485
0
        }
16486
73
      }
16487
681
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16488
681
    } else {
16489
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16490
0
      if (UNEXPECTED(!name)) {
16491
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
16492
0
        break;
16493
0
      }
16494
0
    }
16495
16496
681
#if ZEND_DEBUG
16497
    /* For non-standard object handlers, verify a declared property type in debug builds.
16498
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
16499
681
    zend_property_info *prop_info = NULL;
16500
681
    if (zobj->handlers->read_property != zend_std_read_property) {
16501
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
16502
0
    }
16503
681
#endif
16504
681
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
16505
681
#if ZEND_DEBUG
16506
681
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
16507
681
        && ZEND_TYPE_IS_SET(prop_info->type)) {
16508
0
      ZVAL_OPT_DEREF(retval);
16509
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
16510
0
    }
16511
681
#endif
16512
16513
681
    if (IS_CONST != IS_CONST) {
16514
0
      zend_tmp_string_release(tmp_name);
16515
0
    }
16516
16517
681
    if (retval != EX_VAR(opline->result.var)) {
16518
649
fetch_obj_r_copy:
16519
649
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16520
649
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16521
0
      zend_unwrap_reference(retval);
16522
0
    }
16523
729
  } while (0);
16524
16525
4.51k
fetch_obj_r_finish:
16526
16527
4.51k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16528
4.51k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16529
4.51k
}
16530
16531
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16532
142
{
16533
142
  USE_OPLINE
16534
142
  zval *container;
16535
142
  void **cache_slot = NULL;
16536
16537
142
  SAVE_OPLINE();
16538
142
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16539
16540
142
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16541
142
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16542
101
    do {
16543
101
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16544
0
        container = Z_REFVAL_P(container);
16545
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
16546
0
          break;
16547
0
        }
16548
0
      }
16549
101
      if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
16550
0
        ZVAL_UNDEFINED_OP2();
16551
0
      }
16552
101
      ZVAL_NULL(EX_VAR(opline->result.var));
16553
101
      goto fetch_obj_is_finish;
16554
101
    } while (0);
16555
101
  }
16556
16557
  /* here we are sure we are dealing with an object */
16558
41
  do {
16559
41
    zend_object *zobj = Z_OBJ_P(container);
16560
41
    zend_string *name, *tmp_name;
16561
41
    zval *retval;
16562
16563
41
    if (IS_CONST == IS_CONST) {
16564
41
      cache_slot = CACHE_ADDR(opline->extended_value);
16565
16566
41
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
16567
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
16568
16569
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
16570
0
fetch_obj_is_simple:
16571
0
          retval = OBJ_PROP(zobj, prop_offset);
16572
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
16573
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16574
0
              goto fetch_obj_is_copy;
16575
0
            } else {
16576
0
fetch_obj_is_fast_copy:
16577
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16578
0
              ZEND_VM_NEXT_OPCODE();
16579
0
            }
16580
0
          }
16581
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
16582
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
16583
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
16584
0
            prop_offset = prop_info->offset;
16585
0
            goto fetch_obj_is_simple;
16586
0
          }
16587
          /* Fall through to read_property for hooks. */
16588
0
        } else if (EXPECTED(zobj->properties != NULL)) {
16589
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
16590
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16591
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
16592
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
16593
16594
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
16595
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
16596
16597
0
              if (EXPECTED(p->key == name) ||
16598
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
16599
0
                   EXPECTED(p->key != NULL) &&
16600
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
16601
0
                retval = &p->val;
16602
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16603
0
                  goto fetch_obj_is_copy;
16604
0
                } else {
16605
0
                  goto fetch_obj_is_fast_copy;
16606
0
                }
16607
0
              }
16608
0
            }
16609
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
16610
0
          }
16611
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
16612
0
          if (EXPECTED(retval)) {
16613
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
16614
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
16615
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16616
0
              goto fetch_obj_is_copy;
16617
0
            } else {
16618
0
              goto fetch_obj_is_fast_copy;
16619
0
            }
16620
0
          }
16621
0
        }
16622
0
      }
16623
41
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16624
41
    } else {
16625
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16626
0
      if (UNEXPECTED(!name)) {
16627
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
16628
0
        break;
16629
0
      }
16630
0
    }
16631
16632
41
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
16633
16634
41
    if (IS_CONST != IS_CONST) {
16635
0
      zend_tmp_string_release(tmp_name);
16636
0
    }
16637
16638
41
    if (retval != EX_VAR(opline->result.var)) {
16639
26
fetch_obj_is_copy:
16640
26
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16641
26
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16642
15
      zend_unwrap_reference(retval);
16643
15
    }
16644
41
  } while (0);
16645
16646
142
fetch_obj_is_finish:
16647
16648
142
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16649
142
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16650
142
}
16651
16652
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16653
180k
{
16654
180k
  USE_OPLINE
16655
180k
  zval *op1, *op2;
16656
180k
  zend_string *op1_str, *op2_str, *str;
16657
16658
16659
180k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16660
180k
  op2 = RT_CONSTANT(opline, opline->op2);
16661
180k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
16662
180k
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
16663
180k
    zend_string *op1_str = Z_STR_P(op1);
16664
180k
    zend_string *op2_str = Z_STR_P(op2);
16665
180k
    zend_string *str;
16666
180k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
16667
16668
180k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16669
11
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
16670
11
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
16671
11
      } else {
16672
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16673
0
      }
16674
11
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16675
11
        zend_string_release_ex(op1_str, 0);
16676
11
      }
16677
180k
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16678
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16679
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
16680
0
      } else {
16681
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16682
0
      }
16683
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16684
0
        zend_string_release_ex(op2_str, 0);
16685
0
      }
16686
180k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
16687
180k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
16688
179k
      size_t len = ZSTR_LEN(op1_str);
16689
16690
179k
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
16691
179k
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16692
179k
      GC_ADD_FLAGS(str, flags);
16693
179k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16694
179k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16695
0
        zend_string_release_ex(op2_str, 0);
16696
0
      }
16697
179k
    } else {
16698
649
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16699
649
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16700
649
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16701
649
      GC_ADD_FLAGS(str, flags);
16702
649
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16703
649
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16704
649
        zend_string_release_ex(op1_str, 0);
16705
649
      }
16706
649
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16707
0
        zend_string_release_ex(op2_str, 0);
16708
0
      }
16709
649
    }
16710
180k
    ZEND_VM_NEXT_OPCODE();
16711
180k
  }
16712
16713
180k
  SAVE_OPLINE();
16714
473
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16715
0
    op1_str = Z_STR_P(op1);
16716
473
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16717
0
    op1_str = zend_string_copy(Z_STR_P(op1));
16718
473
  } else {
16719
473
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
16720
0
      ZVAL_UNDEFINED_OP1();
16721
0
    }
16722
473
    op1_str = zval_get_string_func(op1);
16723
473
  }
16724
473
  if (IS_CONST == IS_CONST) {
16725
473
    op2_str = Z_STR_P(op2);
16726
473
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16727
0
    op2_str = zend_string_copy(Z_STR_P(op2));
16728
0
  } else {
16729
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
16730
0
      ZVAL_UNDEFINED_OP2();
16731
0
    }
16732
0
    op2_str = zval_get_string_func(op2);
16733
0
  }
16734
473
  do {
16735
473
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16736
473
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16737
233
        if (IS_CONST == IS_CONST) {
16738
233
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
16739
0
            GC_ADDREF(op2_str);
16740
0
          }
16741
233
        }
16742
233
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16743
233
        zend_string_release_ex(op1_str, 0);
16744
233
        break;
16745
233
      }
16746
473
    }
16747
240
    if (IS_CONST != IS_CONST) {
16748
0
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16749
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16750
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
16751
0
            GC_ADDREF(op1_str);
16752
0
          }
16753
0
        }
16754
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16755
0
        zend_string_release_ex(op2_str, 0);
16756
0
        break;
16757
0
      }
16758
0
    }
16759
240
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16760
240
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16761
240
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16762
16763
240
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
16764
240
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16765
240
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16766
240
      zend_string_release_ex(op1_str, 0);
16767
240
    }
16768
240
    if (IS_CONST != IS_CONST) {
16769
0
      zend_string_release_ex(op2_str, 0);
16770
0
    }
16771
240
  } while (0);
16772
473
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16773
16774
473
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16775
473
}
16776
16777
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16778
4.19k
{
16779
4.19k
  USE_OPLINE
16780
4.19k
  zval *function_name;
16781
4.19k
  zval *object;
16782
4.19k
  zend_function *fbc;
16783
4.19k
  zend_class_entry *called_scope;
16784
4.19k
  zend_object *obj;
16785
4.19k
  zend_execute_data *call;
16786
4.19k
  uint32_t call_info;
16787
16788
4.19k
  SAVE_OPLINE();
16789
16790
4.19k
  object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16791
16792
4.19k
  if (IS_CONST != IS_CONST) {
16793
0
    function_name = RT_CONSTANT(opline, opline->op2);
16794
0
  }
16795
16796
4.19k
  if (IS_CONST != IS_CONST &&
16797
4.19k
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
16798
0
    do {
16799
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
16800
0
        function_name = Z_REFVAL_P(function_name);
16801
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
16802
0
          break;
16803
0
        }
16804
0
      } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
16805
0
        ZVAL_UNDEFINED_OP2();
16806
0
        if (UNEXPECTED(EG(exception) != NULL)) {
16807
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16808
0
          HANDLE_EXCEPTION();
16809
0
        }
16810
0
      }
16811
0
      zend_throw_error(NULL, "Method name must be a string");
16812
16813
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16814
0
      HANDLE_EXCEPTION();
16815
0
    } while (0);
16816
0
  }
16817
16818
4.19k
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
16819
0
    obj = Z_OBJ_P(object);
16820
4.19k
  } else {
16821
4.19k
    do {
16822
4.19k
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16823
4.08k
        obj = Z_OBJ_P(object);
16824
4.08k
      } else {
16825
110
        if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
16826
64
          zend_reference *ref = Z_REF_P(object);
16827
16828
64
          object = &ref->val;
16829
64
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16830
64
            obj = Z_OBJ_P(object);
16831
64
            if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
16832
64
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
16833
2
                efree_size(ref, sizeof(zend_reference));
16834
62
              } else {
16835
62
                Z_ADDREF_P(object);
16836
62
              }
16837
64
            }
16838
64
            break;
16839
64
          }
16840
64
        }
16841
46
        if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
16842
0
          object = ZVAL_UNDEFINED_OP1();
16843
0
          if (UNEXPECTED(EG(exception) != NULL)) {
16844
0
            if (IS_CONST != IS_CONST) {
16845
16846
0
            }
16847
0
            HANDLE_EXCEPTION();
16848
0
          }
16849
0
        }
16850
46
        if (IS_CONST == IS_CONST) {
16851
46
          function_name = RT_CONSTANT(opline, opline->op2);
16852
46
        }
16853
46
        zend_invalid_method_call(object, function_name);
16854
16855
46
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16856
46
        HANDLE_EXCEPTION();
16857
46
      }
16858
4.19k
    } while (0);
16859
4.19k
  }
16860
16861
4.15k
  called_scope = obj->ce;
16862
16863
4.15k
  if (IS_CONST == IS_CONST &&
16864
4.15k
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
16865
582
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
16866
3.57k
  } else {
16867
3.57k
    zend_object *orig_obj = obj;
16868
16869
3.57k
    if (IS_CONST == IS_CONST) {
16870
3.57k
      function_name = RT_CONSTANT(opline, opline->op2);
16871
3.57k
    }
16872
16873
    /* First, locate the function. */
16874
3.57k
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
16875
3.57k
    if (UNEXPECTED(fbc == NULL)) {
16876
39
      if (EXPECTED(!EG(exception))) {
16877
39
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
16878
39
      }
16879
16880
39
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
16881
29
        zend_objects_store_del(orig_obj);
16882
29
      }
16883
39
      HANDLE_EXCEPTION();
16884
39
    }
16885
3.53k
    if (IS_CONST == IS_CONST &&
16886
3.53k
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
16887
3.53k
        EXPECTED(obj == orig_obj)) {
16888
3.48k
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
16889
3.48k
    }
16890
3.53k
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
16891
0
      GC_ADDREF(obj); /* For $this pointer */
16892
0
      if (GC_DELREF(orig_obj) == 0) {
16893
0
        zend_objects_store_del(orig_obj);
16894
0
      }
16895
0
    }
16896
3.53k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
16897
573
      init_func_run_time_cache(&fbc->op_array);
16898
573
    }
16899
3.53k
  }
16900
16901
4.11k
  if (IS_CONST != IS_CONST) {
16902
16903
0
  }
16904
16905
4.11k
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16906
4.11k
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
16907
12
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
16908
12
      zend_objects_store_del(obj);
16909
12
      if (UNEXPECTED(EG(exception))) {
16910
0
        HANDLE_EXCEPTION();
16911
0
      }
16912
12
    }
16913
    /* call static method */
16914
12
    obj = (zend_object*)called_scope;
16915
12
    call_info = ZEND_CALL_NESTED_FUNCTION;
16916
4.10k
  } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
16917
4.10k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
16918
0
      GC_ADDREF(obj); /* For $this pointer */
16919
0
    }
16920
    /* CV may be changed indirectly (e.g. when it's a reference) */
16921
4.10k
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
16922
4.10k
  }
16923
16924
4.11k
  call = zend_vm_stack_push_call_frame(call_info,
16925
4.11k
    fbc, opline->extended_value, obj);
16926
4.11k
  call->prev_execute_data = EX(call);
16927
4.11k
  EX(call) = call;
16928
16929
4.11k
  ZEND_VM_NEXT_OPCODE();
16930
4.11k
}
16931
16932
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16933
20
{
16934
20
  USE_OPLINE
16935
20
  zval *value, *arg;
16936
16937
20
  if (IS_CONST == IS_CONST) {
16938
20
    SAVE_OPLINE();
16939
20
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16940
20
    uint32_t arg_num;
16941
20
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
16942
20
    if (UNEXPECTED(!arg)) {
16943
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16944
0
      HANDLE_EXCEPTION();
16945
0
    }
16946
20
  } else {
16947
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
16948
0
  }
16949
16950
20
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16951
20
  ZVAL_COPY_VALUE(arg, value);
16952
20
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16953
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
16954
0
      Z_ADDREF_P(arg);
16955
0
    }
16956
0
  }
16957
20
  ZEND_VM_NEXT_OPCODE();
16958
20
}
16959
16960
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16961
804
{
16962
804
  USE_OPLINE
16963
804
  zval *op1, *op2;
16964
804
  double d1, d2;
16965
16966
804
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16967
804
  op2 = RT_CONSTANT(opline, opline->op2);
16968
804
  if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16969
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16970
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16971
32
case_true:
16972
32
        ZEND_VM_SMART_BRANCH_TRUE();
16973
32
      } else {
16974
721
case_false:
16975
721
        ZEND_VM_SMART_BRANCH_FALSE();
16976
721
      }
16977
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16978
0
      d1 = (double)Z_LVAL_P(op1);
16979
0
      d2 = Z_DVAL_P(op2);
16980
0
      goto case_double;
16981
0
    }
16982
804
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16983
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16984
0
      d1 = Z_DVAL_P(op1);
16985
0
      d2 = Z_DVAL_P(op2);
16986
0
case_double:
16987
0
      if (d1 == d2) {
16988
0
        goto case_true;
16989
0
      } else {
16990
0
        goto case_false;
16991
0
      }
16992
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16993
0
      d1 = Z_DVAL_P(op1);
16994
0
      d2 = (double)Z_LVAL_P(op2);
16995
0
      goto case_double;
16996
0
    }
16997
804
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16998
753
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16999
753
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17000
17001
753
      if (result) {
17002
32
        goto case_true;
17003
721
      } else {
17004
721
        goto case_false;
17005
721
      }
17006
753
    }
17007
753
  }
17008
804
  ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17009
804
}
17010
17011
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17012
402
{
17013
402
  USE_OPLINE
17014
402
  zval *container;
17015
402
  bool result;
17016
402
  zend_ulong hval;
17017
402
  zval *offset;
17018
17019
402
  SAVE_OPLINE();
17020
402
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17021
402
  offset = RT_CONSTANT(opline, opline->op2);
17022
17023
402
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17024
42
    HashTable *ht;
17025
42
    zval *value;
17026
42
    zend_string *str;
17027
17028
42
isset_dim_obj_array:
17029
42
    ht = Z_ARRVAL_P(container);
17030
42
isset_again:
17031
42
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
17032
22
      str = Z_STR_P(offset);
17033
22
      if (IS_CONST != IS_CONST) {
17034
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
17035
0
          goto num_index_prop;
17036
0
        }
17037
0
      }
17038
22
      value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
17039
22
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
17040
20
      hval = Z_LVAL_P(offset);
17041
20
num_index_prop:
17042
20
      value = zend_hash_index_find(ht, hval);
17043
20
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
17044
0
      offset = Z_REFVAL_P(offset);
17045
0
      goto isset_again;
17046
0
    } else {
17047
0
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
17048
0
      if (UNEXPECTED(EG(exception))) {
17049
0
        result = 0;
17050
0
        goto isset_dim_obj_exit;
17051
0
      }
17052
0
    }
17053
17054
42
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
17055
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
17056
42
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
17057
42
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
17058
17059
42
      if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
17060
        /* avoid exception check */
17061
17062
0
        ZEND_VM_SMART_BRANCH(result, 0);
17063
0
      }
17064
42
    } else {
17065
0
      result = (value == NULL || !i_zend_is_true(value));
17066
0
    }
17067
42
    goto isset_dim_obj_exit;
17068
360
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
17069
0
    container = Z_REFVAL_P(container);
17070
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17071
0
      goto isset_dim_obj_array;
17072
0
    }
17073
0
  }
17074
17075
360
  if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
17076
0
    offset++;
17077
0
  }
17078
360
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
17079
236
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
17080
236
  } else {
17081
124
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
17082
124
  }
17083
17084
402
isset_dim_obj_exit:
17085
17086
402
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17087
402
  ZEND_VM_SMART_BRANCH(result, 1);
17088
402
}
17089
17090
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17091
158
{
17092
158
  USE_OPLINE
17093
158
  zval *container;
17094
158
  int result;
17095
158
  zval *offset;
17096
158
  zend_string *name, *tmp_name;
17097
17098
158
  SAVE_OPLINE();
17099
158
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17100
158
  offset = RT_CONSTANT(opline, opline->op2);
17101
17102
158
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17103
158
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17104
119
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17105
0
      container = Z_REFVAL_P(container);
17106
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
17107
0
        result = (opline->extended_value & ZEND_ISEMPTY);
17108
0
        goto isset_object_finish;
17109
0
      }
17110
119
    } else {
17111
119
      result = (opline->extended_value & ZEND_ISEMPTY);
17112
119
      goto isset_object_finish;
17113
119
    }
17114
119
  }
17115
17116
39
  if (IS_CONST == IS_CONST) {
17117
39
    name = Z_STR_P(offset);
17118
39
  } else {
17119
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
17120
0
    if (UNEXPECTED(!name)) {
17121
0
      result = 0;
17122
0
      goto isset_object_finish;
17123
0
    }
17124
0
  }
17125
17126
39
  result =
17127
39
    (opline->extended_value & ZEND_ISEMPTY) ^
17128
39
    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));
17129
17130
39
  if (IS_CONST != IS_CONST) {
17131
0
    zend_tmp_string_release(tmp_name);
17132
0
  }
17133
17134
158
isset_object_finish:
17135
17136
158
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17137
158
  ZEND_VM_SMART_BRANCH(result, 1);
17138
158
}
17139
17140
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17141
9
{
17142
9
  USE_OPLINE
17143
17144
9
  zval *key, *subject;
17145
9
  HashTable *ht;
17146
9
  bool result;
17147
17148
9
  SAVE_OPLINE();
17149
17150
9
  key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17151
9
  subject = RT_CONSTANT(opline, opline->op2);
17152
17153
9
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
17154
9
array_key_exists_array:
17155
9
    ht = Z_ARRVAL_P(subject);
17156
9
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
17157
9
  } else {
17158
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
17159
0
      subject = Z_REFVAL_P(subject);
17160
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
17161
0
        goto array_key_exists_array;
17162
0
      }
17163
0
    }
17164
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
17165
0
    result = 0;
17166
0
  }
17167
17168
9
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17169
9
  ZEND_VM_SMART_BRANCH(result, 1);
17170
9
}
17171
17172
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17173
238
{
17174
238
  USE_OPLINE
17175
238
  zval *expr;
17176
238
  bool result;
17177
17178
238
  SAVE_OPLINE();
17179
238
  expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17180
17181
238
try_instanceof:
17182
238
  if (Z_TYPE_P(expr) == IS_OBJECT) {
17183
217
    zend_class_entry *ce;
17184
17185
217
    if (IS_CONST == IS_CONST) {
17186
217
      ce = CACHED_PTR(opline->extended_value);
17187
217
      if (UNEXPECTED(ce == NULL)) {
17188
109
        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);
17189
109
        if (EXPECTED(ce)) {
17190
94
          CACHE_PTR(opline->extended_value, ce);
17191
94
        }
17192
109
      }
17193
217
    } else if (IS_CONST == IS_UNUSED) {
17194
0
      ce = zend_fetch_class(NULL, opline->op2.num);
17195
0
      if (UNEXPECTED(ce == NULL)) {
17196
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17197
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
17198
0
        HANDLE_EXCEPTION();
17199
0
      }
17200
0
    } else {
17201
0
      ce = Z_CE_P(EX_VAR(opline->op2.var));
17202
0
    }
17203
217
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
17204
217
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
17205
0
    expr = Z_REFVAL_P(expr);
17206
0
    goto try_instanceof;
17207
21
  } else {
17208
21
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
17209
0
      ZVAL_UNDEFINED_OP1();
17210
0
    }
17211
21
    result = 0;
17212
21
  }
17213
238
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17214
238
  ZEND_VM_SMART_BRANCH(result, 1);
17215
238
}
17216
17217
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17218
1.98k
{
17219
1.98k
  USE_OPLINE
17220
1.98k
  zval *container, *dim, *value;
17221
1.98k
  zend_long offset;
17222
1.98k
  HashTable *ht;
17223
17224
1.98k
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17225
1.98k
  dim = RT_CONSTANT(opline, opline->op2);
17226
1.98k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17227
1.26k
fetch_dim_r_index_array:
17228
1.26k
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
17229
1.25k
      offset = Z_LVAL_P(dim);
17230
1.25k
    } else {
17231
6
      SAVE_OPLINE();
17232
6
      zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
17233
6
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17234
6
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17235
6
    }
17236
1.25k
    ht = Z_ARRVAL_P(container);
17237
1.25k
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
17238
964
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17239
964
    if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17240
964
      SAVE_OPLINE();
17241
964
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17242
964
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17243
964
    } else {
17244
0
      ZEND_VM_NEXT_OPCODE();
17245
0
    }
17246
964
  } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17247
89
    container = Z_REFVAL_P(container);
17248
89
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17249
84
      goto fetch_dim_r_index_array;
17250
84
    } else {
17251
5
      goto fetch_dim_r_index_slow;
17252
5
    }
17253
719
  } else {
17254
724
fetch_dim_r_index_slow:
17255
724
    SAVE_OPLINE();
17256
724
    if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17257
0
      dim++;
17258
0
    }
17259
724
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17260
724
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17261
724
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17262
724
  }
17263
17264
292
fetch_dim_r_index_undef:
17265
292
  ZVAL_NULL(EX_VAR(opline->result.var));
17266
292
  SAVE_OPLINE();
17267
292
  zend_undefined_offset(offset);
17268
292
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17269
292
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17270
292
}
17271
17272
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17273
758
{
17274
758
  USE_OPLINE
17275
758
  zval *container, *dim, *value;
17276
758
  zend_long offset;
17277
758
  HashTable *ht;
17278
17279
758
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17280
758
  dim = EX_VAR(opline->op2.var);
17281
758
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17282
100
fetch_dim_r_index_array:
17283
100
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
17284
100
      offset = Z_LVAL_P(dim);
17285
100
    } else {
17286
0
      SAVE_OPLINE();
17287
0
      zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
17288
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17289
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17290
0
    }
17291
100
    ht = Z_ARRVAL_P(container);
17292
100
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
17293
89
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17294
89
    if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17295
89
      SAVE_OPLINE();
17296
89
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17297
89
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17298
89
    } else {
17299
0
      ZEND_VM_NEXT_OPCODE();
17300
0
    }
17301
658
  } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17302
0
    container = Z_REFVAL_P(container);
17303
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17304
0
      goto fetch_dim_r_index_array;
17305
0
    } else {
17306
0
      goto fetch_dim_r_index_slow;
17307
0
    }
17308
658
  } else {
17309
658
fetch_dim_r_index_slow:
17310
658
    SAVE_OPLINE();
17311
658
    if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17312
0
      dim++;
17313
0
    }
17314
658
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17315
658
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17316
658
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17317
658
  }
17318
17319
11
fetch_dim_r_index_undef:
17320
11
  ZVAL_NULL(EX_VAR(opline->result.var));
17321
11
  SAVE_OPLINE();
17322
11
  zend_undefined_offset(offset);
17323
11
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17324
11
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17325
11
}
17326
17327
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17328
79
{
17329
79
  USE_OPLINE
17330
79
  zval *op1, *op2;
17331
17332
79
  SAVE_OPLINE();
17333
79
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17334
79
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17335
79
  div_function(EX_VAR(opline->result.var), op1, op2);
17336
79
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17337
79
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17338
79
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17339
79
}
17340
17341
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17342
0
{
17343
0
  USE_OPLINE
17344
0
  zval *op1, *op2;
17345
17346
0
  SAVE_OPLINE();
17347
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17348
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17349
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
17350
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17351
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17352
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17353
0
}
17354
17355
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17356
9.73k
{
17357
9.73k
  USE_OPLINE
17358
9.73k
  zval *op1, *op2;
17359
17360
9.73k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17361
9.73k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17362
17363
9.73k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
17364
9.73k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
17365
3.32k
    zend_string *op1_str = Z_STR_P(op1);
17366
3.32k
    zend_string *op2_str = Z_STR_P(op2);
17367
3.32k
    zend_string *str;
17368
3.32k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
17369
17370
3.32k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17371
101
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17372
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
17373
101
      } else {
17374
101
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17375
101
      }
17376
101
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17377
101
        zend_string_release_ex(op1_str, 0);
17378
101
      }
17379
3.22k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17380
185
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17381
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
17382
185
      } else {
17383
185
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17384
185
      }
17385
185
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17386
185
        zend_string_release_ex(op2_str, 0);
17387
185
      }
17388
3.04k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
17389
3.04k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
17390
2.72k
      size_t len = ZSTR_LEN(op1_str);
17391
17392
2.72k
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
17393
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
17394
0
      }
17395
2.72k
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
17396
2.72k
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17397
2.72k
      GC_ADD_FLAGS(str, flags);
17398
2.72k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17399
2.72k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17400
2.72k
        zend_string_release_ex(op2_str, 0);
17401
2.72k
      }
17402
2.72k
    } else {
17403
317
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17404
317
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17405
317
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17406
317
      GC_ADD_FLAGS(str, flags);
17407
317
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17408
317
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17409
317
        zend_string_release_ex(op1_str, 0);
17410
317
      }
17411
317
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17412
317
        zend_string_release_ex(op2_str, 0);
17413
317
      }
17414
317
    }
17415
3.32k
    ZEND_VM_NEXT_OPCODE();
17416
6.40k
  } else {
17417
6.40k
    SAVE_OPLINE();
17418
17419
6.40k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
17420
0
      op1 = ZVAL_UNDEFINED_OP1();
17421
0
    }
17422
6.40k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
17423
0
      op2 = ZVAL_UNDEFINED_OP2();
17424
0
    }
17425
6.40k
    concat_function(EX_VAR(opline->result.var), op1, op2);
17426
6.40k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17427
6.40k
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17428
6.40k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17429
6.40k
  }
17430
9.73k
}
17431
17432
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17433
1.39k
{
17434
1.39k
  USE_OPLINE
17435
1.39k
  zval *op1, *op2;
17436
1.39k
  double d1, d2;
17437
17438
1.39k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17439
1.39k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17440
1.39k
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17441
    /* pass */
17442
1.39k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17443
725
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17444
640
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17445
264
is_equal_true:
17446
264
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
17447
449
      } else {
17448
935
is_equal_false:
17449
935
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
17450
935
      }
17451
640
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17452
3
      d1 = (double)Z_LVAL_P(op1);
17453
3
      d2 = Z_DVAL_P(op2);
17454
3
      goto is_equal_double;
17455
3
    }
17456
725
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17457
530
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17458
405
      d1 = Z_DVAL_P(op1);
17459
405
      d2 = Z_DVAL_P(op2);
17460
533
is_equal_double:
17461
533
      if (d1 == d2) {
17462
61
        goto is_equal_true;
17463
472
      } else {
17464
472
        goto is_equal_false;
17465
472
      }
17466
533
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17467
125
      d1 = Z_DVAL_P(op1);
17468
125
      d2 = (double)Z_LVAL_P(op2);
17469
125
      goto is_equal_double;
17470
125
    }
17471
530
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17472
26
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17473
26
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17474
26
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17475
26
        zval_ptr_dtor_str(op1);
17476
26
      }
17477
26
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17478
26
        zval_ptr_dtor_str(op2);
17479
26
      }
17480
26
      if (result) {
17481
12
        goto is_equal_true;
17482
14
      } else {
17483
14
        goto is_equal_false;
17484
14
      }
17485
26
    }
17486
26
  }
17487
1.39k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17488
1.39k
}
17489
17490
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17491
76
{
17492
76
  USE_OPLINE
17493
76
  zval *op1, *op2;
17494
76
  double d1, d2;
17495
17496
76
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17497
76
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17498
76
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17499
    /* pass */
17500
76
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17501
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17502
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17503
0
is_equal_true:
17504
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17505
0
      } else {
17506
0
is_equal_false:
17507
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17508
0
      }
17509
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17510
0
      d1 = (double)Z_LVAL_P(op1);
17511
0
      d2 = Z_DVAL_P(op2);
17512
0
      goto is_equal_double;
17513
0
    }
17514
76
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17515
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17516
0
      d1 = Z_DVAL_P(op1);
17517
0
      d2 = Z_DVAL_P(op2);
17518
0
is_equal_double:
17519
0
      if (d1 == d2) {
17520
0
        goto is_equal_true;
17521
0
      } else {
17522
0
        goto is_equal_false;
17523
0
      }
17524
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17525
0
      d1 = Z_DVAL_P(op1);
17526
0
      d2 = (double)Z_LVAL_P(op2);
17527
0
      goto is_equal_double;
17528
0
    }
17529
76
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17530
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17531
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17532
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17533
0
        zval_ptr_dtor_str(op1);
17534
0
      }
17535
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17536
0
        zval_ptr_dtor_str(op2);
17537
0
      }
17538
0
      if (result) {
17539
0
        goto is_equal_true;
17540
0
      } else {
17541
0
        goto is_equal_false;
17542
0
      }
17543
0
    }
17544
0
  }
17545
76
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17546
76
}
17547
17548
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17549
3
{
17550
3
  USE_OPLINE
17551
3
  zval *op1, *op2;
17552
3
  double d1, d2;
17553
17554
3
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17555
3
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17556
3
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17557
    /* pass */
17558
3
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17559
3
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17560
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17561
0
is_equal_true:
17562
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17563
0
      } else {
17564
0
is_equal_false:
17565
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17566
0
      }
17567
3
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17568
0
      d1 = (double)Z_LVAL_P(op1);
17569
0
      d2 = Z_DVAL_P(op2);
17570
0
      goto is_equal_double;
17571
0
    }
17572
3
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17573
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17574
0
      d1 = Z_DVAL_P(op1);
17575
0
      d2 = Z_DVAL_P(op2);
17576
0
is_equal_double:
17577
0
      if (d1 == d2) {
17578
0
        goto is_equal_true;
17579
0
      } else {
17580
0
        goto is_equal_false;
17581
0
      }
17582
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17583
0
      d1 = Z_DVAL_P(op1);
17584
0
      d2 = (double)Z_LVAL_P(op2);
17585
0
      goto is_equal_double;
17586
0
    }
17587
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17588
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17589
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17590
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17591
0
        zval_ptr_dtor_str(op1);
17592
0
      }
17593
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17594
0
        zval_ptr_dtor_str(op2);
17595
0
      }
17596
0
      if (result) {
17597
0
        goto is_equal_true;
17598
0
      } else {
17599
0
        goto is_equal_false;
17600
0
      }
17601
0
    }
17602
0
  }
17603
3
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17604
3
}
17605
17606
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17607
508
{
17608
508
  USE_OPLINE
17609
508
  zval *op1, *op2;
17610
508
  double d1, d2;
17611
17612
508
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17613
508
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17614
508
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17615
    /* pass */
17616
508
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17617
101
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17618
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17619
162
is_not_equal_true:
17620
162
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
17621
162
      } else {
17622
45
is_not_equal_false:
17623
45
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
17624
45
      }
17625
101
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17626
0
      d1 = (double)Z_LVAL_P(op1);
17627
0
      d2 = Z_DVAL_P(op2);
17628
0
      goto is_not_equal_double;
17629
0
    }
17630
407
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17631
67
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17632
0
      d1 = Z_DVAL_P(op1);
17633
0
      d2 = Z_DVAL_P(op2);
17634
0
is_not_equal_double:
17635
0
      if (d1 != d2) {
17636
0
        goto is_not_equal_true;
17637
0
      } else {
17638
0
        goto is_not_equal_false;
17639
0
      }
17640
67
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17641
0
      d1 = Z_DVAL_P(op1);
17642
0
      d2 = (double)Z_LVAL_P(op2);
17643
0
      goto is_not_equal_double;
17644
0
    }
17645
340
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17646
267
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17647
207
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17648
207
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17649
207
        zval_ptr_dtor_str(op1);
17650
207
      }
17651
207
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17652
207
        zval_ptr_dtor_str(op2);
17653
207
      }
17654
207
      if (!result) {
17655
162
        goto is_not_equal_true;
17656
162
      } else {
17657
45
        goto is_not_equal_false;
17658
45
      }
17659
207
    }
17660
267
  }
17661
508
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17662
508
}
17663
17664
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17665
118
{
17666
118
  USE_OPLINE
17667
118
  zval *op1, *op2;
17668
118
  double d1, d2;
17669
17670
118
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17671
118
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17672
118
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17673
    /* pass */
17674
118
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17675
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17676
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17677
0
is_not_equal_true:
17678
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17679
0
      } else {
17680
0
is_not_equal_false:
17681
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17682
0
      }
17683
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17684
0
      d1 = (double)Z_LVAL_P(op1);
17685
0
      d2 = Z_DVAL_P(op2);
17686
0
      goto is_not_equal_double;
17687
0
    }
17688
118
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17689
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17690
0
      d1 = Z_DVAL_P(op1);
17691
0
      d2 = Z_DVAL_P(op2);
17692
0
is_not_equal_double:
17693
0
      if (d1 != d2) {
17694
0
        goto is_not_equal_true;
17695
0
      } else {
17696
0
        goto is_not_equal_false;
17697
0
      }
17698
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17699
0
      d1 = Z_DVAL_P(op1);
17700
0
      d2 = (double)Z_LVAL_P(op2);
17701
0
      goto is_not_equal_double;
17702
0
    }
17703
118
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17704
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17705
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17706
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17707
0
        zval_ptr_dtor_str(op1);
17708
0
      }
17709
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17710
0
        zval_ptr_dtor_str(op2);
17711
0
      }
17712
0
      if (!result) {
17713
0
        goto is_not_equal_true;
17714
0
      } else {
17715
0
        goto is_not_equal_false;
17716
0
      }
17717
0
    }
17718
0
  }
17719
118
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17720
118
}
17721
17722
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17723
10
{
17724
10
  USE_OPLINE
17725
10
  zval *op1, *op2;
17726
10
  double d1, d2;
17727
17728
10
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17729
10
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17730
10
  if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17731
    /* pass */
17732
10
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17733
7
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17734
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17735
5
is_not_equal_true:
17736
5
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17737
5
      } else {
17738
0
is_not_equal_false:
17739
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17740
0
      }
17741
7
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17742
2
      d1 = (double)Z_LVAL_P(op1);
17743
2
      d2 = Z_DVAL_P(op2);
17744
2
      goto is_not_equal_double;
17745
2
    }
17746
7
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17747
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17748
0
      d1 = Z_DVAL_P(op1);
17749
0
      d2 = Z_DVAL_P(op2);
17750
2
is_not_equal_double:
17751
2
      if (d1 != d2) {
17752
2
        goto is_not_equal_true;
17753
2
      } else {
17754
0
        goto is_not_equal_false;
17755
0
      }
17756
2
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17757
0
      d1 = Z_DVAL_P(op1);
17758
0
      d2 = (double)Z_LVAL_P(op2);
17759
0
      goto is_not_equal_double;
17760
0
    }
17761
3
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17762
3
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17763
3
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17764
3
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17765
3
        zval_ptr_dtor_str(op1);
17766
3
      }
17767
3
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17768
3
        zval_ptr_dtor_str(op2);
17769
3
      }
17770
3
      if (!result) {
17771
3
        goto is_not_equal_true;
17772
3
      } else {
17773
0
        goto is_not_equal_false;
17774
0
      }
17775
3
    }
17776
3
  }
17777
10
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
17778
10
}
17779
17780
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17781
0
{
17782
0
  USE_OPLINE
17783
0
  zval *op1, *op2;
17784
17785
0
  SAVE_OPLINE();
17786
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17787
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17788
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
17789
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17790
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17791
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17792
0
}
17793
17794
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17795
557
{
17796
557
  USE_OPLINE
17797
557
  zval *op1, *op2;
17798
17799
557
  SAVE_OPLINE();
17800
557
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17801
557
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17802
557
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
17803
557
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17804
557
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17805
557
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17806
557
}
17807
17808
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17809
1.07k
{
17810
1.07k
  USE_OPLINE
17811
1.07k
  zval *container, *dim, *value;
17812
17813
1.07k
  SAVE_OPLINE();
17814
1.07k
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17815
1.07k
  dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17816
1.07k
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17817
1.07k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17818
839
fetch_dim_r_array:
17819
839
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
17820
839
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17821
839
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17822
0
      container = Z_REFVAL_P(container);
17823
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17824
0
        goto fetch_dim_r_array;
17825
0
      } else {
17826
0
        goto fetch_dim_r_slow;
17827
0
      }
17828
237
    } else {
17829
237
fetch_dim_r_slow:
17830
237
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17831
0
        dim++;
17832
0
      }
17833
237
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17834
237
    }
17835
1.07k
  } else {
17836
0
    zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
17837
0
  }
17838
1.07k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17839
1.07k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17840
1.07k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17841
1.07k
}
17842
17843
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17844
551
{
17845
551
  USE_OPLINE
17846
551
  zval *container;
17847
17848
551
  SAVE_OPLINE();
17849
551
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17850
551
  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);
17851
551
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17852
551
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17853
551
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17854
551
}
17855
17856
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17857
16
{
17858
16
  USE_OPLINE
17859
16
  zval *container;
17860
16
  void **cache_slot = NULL;
17861
17862
16
  SAVE_OPLINE();
17863
16
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17864
17865
16
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17866
16
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17867
16
    do {
17868
16
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17869
0
        container = Z_REFVAL_P(container);
17870
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17871
0
          break;
17872
0
        }
17873
0
      }
17874
16
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
17875
0
        ZVAL_UNDEFINED_OP1();
17876
0
      }
17877
16
      zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17878
16
      ZVAL_NULL(EX_VAR(opline->result.var));
17879
16
      goto fetch_obj_r_finish;
17880
16
    } while (0);
17881
16
  }
17882
17883
  /* here we are sure we are dealing with an object */
17884
0
  do {
17885
0
    zend_object *zobj = Z_OBJ_P(container);
17886
0
    zend_string *name, *tmp_name;
17887
0
    zval *retval;
17888
17889
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17890
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
17891
17892
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17893
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17894
17895
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17896
0
fetch_obj_r_simple:
17897
0
          retval = OBJ_PROP(zobj, prop_offset);
17898
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
17899
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17900
0
              goto fetch_obj_r_copy;
17901
0
            } else {
17902
0
fetch_obj_r_fast_copy:
17903
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17904
0
              ZEND_VM_NEXT_OPCODE();
17905
0
            }
17906
0
          }
17907
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
17908
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
17909
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
17910
0
            prop_offset = prop_info->offset;
17911
0
            goto fetch_obj_r_simple;
17912
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
17913
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
17914
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
17915
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
17916
17917
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
17918
0
            if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
17919
0
              GC_ADDREF(zobj);
17920
0
            }
17921
0
            if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
17922
0
              call_info |= ZEND_CALL_RELEASE_THIS;
17923
0
            }
17924
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
17925
0
            call->prev_execute_data = execute_data;
17926
0
            call->call = NULL;
17927
0
            call->return_value = EX_VAR(opline->result.var);
17928
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
17929
17930
0
            execute_data = call;
17931
0
            EG(current_execute_data) = execute_data;
17932
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
17933
17934
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
17935
            opline = hook->op_array.opcodes;
17936
#else
17937
0
            EX(opline) = hook->op_array.opcodes;
17938
0
#endif
17939
0
            LOAD_OPLINE_EX();
17940
17941
17942
0
            ZEND_VM_ENTER_EX();
17943
0
          }
17944
          /* Fall through to read_property for hooks. */
17945
0
        } else if (EXPECTED(zobj->properties != NULL)) {
17946
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
17947
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17948
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17949
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17950
17951
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17952
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17953
17954
0
              if (EXPECTED(p->key == name) ||
17955
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
17956
0
                   EXPECTED(p->key != NULL) &&
17957
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
17958
0
                retval = &p->val;
17959
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17960
0
                  goto fetch_obj_r_copy;
17961
0
                } else {
17962
0
                  goto fetch_obj_r_fast_copy;
17963
0
                }
17964
0
              }
17965
0
            }
17966
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17967
0
          }
17968
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
17969
0
          if (EXPECTED(retval)) {
17970
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17971
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17972
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17973
0
              goto fetch_obj_r_copy;
17974
0
            } else {
17975
0
              goto fetch_obj_r_fast_copy;
17976
0
            }
17977
0
          }
17978
0
        }
17979
0
      }
17980
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17981
0
    } else {
17982
0
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17983
0
      if (UNEXPECTED(!name)) {
17984
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
17985
0
        break;
17986
0
      }
17987
0
    }
17988
17989
0
#if ZEND_DEBUG
17990
    /* For non-standard object handlers, verify a declared property type in debug builds.
17991
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
17992
0
    zend_property_info *prop_info = NULL;
17993
0
    if (zobj->handlers->read_property != zend_std_read_property) {
17994
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
17995
0
    }
17996
0
#endif
17997
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
17998
0
#if ZEND_DEBUG
17999
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
18000
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
18001
0
      ZVAL_OPT_DEREF(retval);
18002
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
18003
0
    }
18004
0
#endif
18005
18006
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18007
0
      zend_tmp_string_release(tmp_name);
18008
0
    }
18009
18010
0
    if (retval != EX_VAR(opline->result.var)) {
18011
0
fetch_obj_r_copy:
18012
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18013
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
18014
0
      zend_unwrap_reference(retval);
18015
0
    }
18016
0
  } while (0);
18017
18018
16
fetch_obj_r_finish:
18019
16
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18020
16
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18021
16
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18022
16
}
18023
18024
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18025
7
{
18026
7
  USE_OPLINE
18027
7
  zval *container;
18028
7
  void **cache_slot = NULL;
18029
18030
7
  SAVE_OPLINE();
18031
7
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18032
18033
7
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18034
7
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18035
0
    do {
18036
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18037
0
        container = Z_REFVAL_P(container);
18038
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
18039
0
          break;
18040
0
        }
18041
0
      }
18042
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
18043
0
        ZVAL_UNDEFINED_OP2();
18044
0
      }
18045
0
      ZVAL_NULL(EX_VAR(opline->result.var));
18046
0
      goto fetch_obj_is_finish;
18047
0
    } while (0);
18048
0
  }
18049
18050
  /* here we are sure we are dealing with an object */
18051
7
  do {
18052
7
    zend_object *zobj = Z_OBJ_P(container);
18053
7
    zend_string *name, *tmp_name;
18054
7
    zval *retval;
18055
18056
7
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18057
0
      cache_slot = CACHE_ADDR(opline->extended_value);
18058
18059
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
18060
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
18061
18062
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
18063
0
fetch_obj_is_simple:
18064
0
          retval = OBJ_PROP(zobj, prop_offset);
18065
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
18066
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18067
0
              goto fetch_obj_is_copy;
18068
0
            } else {
18069
0
fetch_obj_is_fast_copy:
18070
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18071
0
              ZEND_VM_NEXT_OPCODE();
18072
0
            }
18073
0
          }
18074
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
18075
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
18076
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
18077
0
            prop_offset = prop_info->offset;
18078
0
            goto fetch_obj_is_simple;
18079
0
          }
18080
          /* Fall through to read_property for hooks. */
18081
0
        } else if (EXPECTED(zobj->properties != NULL)) {
18082
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
18083
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
18084
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
18085
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
18086
18087
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
18088
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
18089
18090
0
              if (EXPECTED(p->key == name) ||
18091
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
18092
0
                   EXPECTED(p->key != NULL) &&
18093
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
18094
0
                retval = &p->val;
18095
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18096
0
                  goto fetch_obj_is_copy;
18097
0
                } else {
18098
0
                  goto fetch_obj_is_fast_copy;
18099
0
                }
18100
0
              }
18101
0
            }
18102
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
18103
0
          }
18104
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
18105
0
          if (EXPECTED(retval)) {
18106
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
18107
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
18108
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18109
0
              goto fetch_obj_is_copy;
18110
0
            } else {
18111
0
              goto fetch_obj_is_fast_copy;
18112
0
            }
18113
0
          }
18114
0
        }
18115
0
      }
18116
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
18117
7
    } else {
18118
7
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
18119
7
      if (UNEXPECTED(!name)) {
18120
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
18121
0
        break;
18122
0
      }
18123
7
    }
18124
18125
7
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
18126
18127
7
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18128
7
      zend_tmp_string_release(tmp_name);
18129
7
    }
18130
18131
7
    if (retval != EX_VAR(opline->result.var)) {
18132
7
fetch_obj_is_copy:
18133
7
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18134
7
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
18135
0
      zend_unwrap_reference(retval);
18136
0
    }
18137
7
  } while (0);
18138
18139
7
fetch_obj_is_finish:
18140
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18141
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18142
7
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18143
7
}
18144
18145
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18146
8.50k
{
18147
8.50k
  USE_OPLINE
18148
8.50k
  zval *op1, *op2;
18149
8.50k
  zend_string *op1_str, *op2_str, *str;
18150
18151
18152
8.50k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18153
8.50k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18154
8.50k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
18155
8.50k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
18156
5.01k
    zend_string *op1_str = Z_STR_P(op1);
18157
5.01k
    zend_string *op2_str = Z_STR_P(op2);
18158
5.01k
    zend_string *str;
18159
5.01k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
18160
18161
5.01k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18162
15
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18163
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
18164
15
      } else {
18165
15
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18166
15
      }
18167
15
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18168
15
        zend_string_release_ex(op1_str, 0);
18169
15
      }
18170
5.00k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18171
27
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18172
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
18173
27
      } else {
18174
27
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18175
27
      }
18176
27
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18177
27
        zend_string_release_ex(op2_str, 0);
18178
27
      }
18179
4.97k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
18180
4.97k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
18181
4.86k
      size_t len = ZSTR_LEN(op1_str);
18182
18183
4.86k
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
18184
4.86k
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18185
4.86k
      GC_ADD_FLAGS(str, flags);
18186
4.86k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18187
4.86k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18188
4.85k
        zend_string_release_ex(op2_str, 0);
18189
4.85k
      }
18190
4.86k
    } else {
18191
113
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18192
113
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18193
113
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18194
113
      GC_ADD_FLAGS(str, flags);
18195
113
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18196
113
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18197
113
        zend_string_release_ex(op1_str, 0);
18198
113
      }
18199
113
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18200
113
        zend_string_release_ex(op2_str, 0);
18201
113
      }
18202
113
    }
18203
5.01k
    ZEND_VM_NEXT_OPCODE();
18204
5.01k
  }
18205
18206
8.50k
  SAVE_OPLINE();
18207
3.48k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18208
0
    op1_str = Z_STR_P(op1);
18209
3.48k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18210
1.54k
    op1_str = zend_string_copy(Z_STR_P(op1));
18211
1.94k
  } else {
18212
1.94k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18213
0
      ZVAL_UNDEFINED_OP1();
18214
0
    }
18215
1.94k
    op1_str = zval_get_string_func(op1);
18216
1.94k
  }
18217
3.48k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18218
0
    op2_str = Z_STR_P(op2);
18219
3.48k
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18220
12
    op2_str = zend_string_copy(Z_STR_P(op2));
18221
3.47k
  } else {
18222
3.47k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
18223
0
      ZVAL_UNDEFINED_OP2();
18224
0
    }
18225
3.47k
    op2_str = zval_get_string_func(op2);
18226
3.47k
  }
18227
3.48k
  do {
18228
3.48k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18229
3.48k
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18230
1.49k
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18231
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
18232
0
            GC_ADDREF(op2_str);
18233
0
          }
18234
0
        }
18235
1.49k
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18236
1.49k
        zend_string_release_ex(op1_str, 0);
18237
1.49k
        break;
18238
1.49k
      }
18239
3.48k
    }
18240
1.99k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18241
1.99k
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18242
29
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18243
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
18244
0
            GC_ADDREF(op1_str);
18245
0
          }
18246
0
        }
18247
29
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18248
29
        zend_string_release_ex(op2_str, 0);
18249
29
        break;
18250
29
      }
18251
1.99k
    }
18252
1.96k
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18253
1.96k
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18254
1.96k
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18255
18256
1.96k
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
18257
1.96k
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18258
1.96k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18259
1.96k
      zend_string_release_ex(op1_str, 0);
18260
1.96k
    }
18261
1.96k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18262
1.96k
      zend_string_release_ex(op2_str, 0);
18263
1.96k
    }
18264
1.96k
  } while (0);
18265
3.48k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18266
3.48k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18267
3.48k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18268
3.48k
}
18269
18270
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18271
25
{
18272
25
  USE_OPLINE
18273
25
  zval *function_name;
18274
25
  zval *object;
18275
25
  zend_function *fbc;
18276
25
  zend_class_entry *called_scope;
18277
25
  zend_object *obj;
18278
25
  zend_execute_data *call;
18279
25
  uint32_t call_info;
18280
18281
25
  SAVE_OPLINE();
18282
18283
25
  object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18284
18285
25
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18286
25
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18287
25
  }
18288
18289
25
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
18290
25
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18291
0
    do {
18292
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
18293
0
        function_name = Z_REFVAL_P(function_name);
18294
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
18295
0
          break;
18296
0
        }
18297
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
18298
0
        ZVAL_UNDEFINED_OP2();
18299
0
        if (UNEXPECTED(EG(exception) != NULL)) {
18300
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18301
0
          HANDLE_EXCEPTION();
18302
0
        }
18303
0
      }
18304
0
      zend_throw_error(NULL, "Method name must be a string");
18305
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18306
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18307
0
      HANDLE_EXCEPTION();
18308
0
    } while (0);
18309
0
  }
18310
18311
25
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18312
0
    obj = Z_OBJ_P(object);
18313
25
  } else {
18314
25
    do {
18315
25
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18316
25
        obj = Z_OBJ_P(object);
18317
25
      } else {
18318
0
        if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
18319
0
          zend_reference *ref = Z_REF_P(object);
18320
18321
0
          object = &ref->val;
18322
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18323
0
            obj = Z_OBJ_P(object);
18324
0
            if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
18325
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
18326
0
                efree_size(ref, sizeof(zend_reference));
18327
0
              } else {
18328
0
                Z_ADDREF_P(object);
18329
0
              }
18330
0
            }
18331
0
            break;
18332
0
          }
18333
0
        }
18334
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
18335
0
          object = ZVAL_UNDEFINED_OP1();
18336
0
          if (UNEXPECTED(EG(exception) != NULL)) {
18337
0
            if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18338
0
              zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18339
0
            }
18340
0
            HANDLE_EXCEPTION();
18341
0
          }
18342
0
        }
18343
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18344
0
          function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18345
0
        }
18346
0
        zend_invalid_method_call(object, function_name);
18347
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18348
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18349
0
        HANDLE_EXCEPTION();
18350
0
      }
18351
25
    } while (0);
18352
25
  }
18353
18354
25
  called_scope = obj->ce;
18355
18356
25
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
18357
25
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
18358
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
18359
25
  } else {
18360
25
    zend_object *orig_obj = obj;
18361
18362
25
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18363
0
      function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18364
0
    }
18365
18366
    /* First, locate the function. */
18367
25
    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));
18368
25
    if (UNEXPECTED(fbc == NULL)) {
18369
0
      if (EXPECTED(!EG(exception))) {
18370
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
18371
0
      }
18372
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18373
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
18374
0
        zend_objects_store_del(orig_obj);
18375
0
      }
18376
0
      HANDLE_EXCEPTION();
18377
0
    }
18378
25
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
18379
25
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
18380
25
        EXPECTED(obj == orig_obj)) {
18381
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
18382
0
    }
18383
25
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
18384
0
      GC_ADDREF(obj); /* For $this pointer */
18385
0
      if (GC_DELREF(orig_obj) == 0) {
18386
0
        zend_objects_store_del(orig_obj);
18387
0
      }
18388
0
    }
18389
25
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
18390
5
      init_func_run_time_cache(&fbc->op_array);
18391
5
    }
18392
25
  }
18393
18394
25
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18395
25
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18396
25
  }
18397
18398
25
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
18399
25
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
18400
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
18401
0
      zend_objects_store_del(obj);
18402
0
      if (UNEXPECTED(EG(exception))) {
18403
0
        HANDLE_EXCEPTION();
18404
0
      }
18405
0
    }
18406
    /* call static method */
18407
0
    obj = (zend_object*)called_scope;
18408
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
18409
25
  } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
18410
25
    if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18411
0
      GC_ADDREF(obj); /* For $this pointer */
18412
0
    }
18413
    /* CV may be changed indirectly (e.g. when it's a reference) */
18414
25
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
18415
25
  }
18416
18417
25
  call = zend_vm_stack_push_call_frame(call_info,
18418
25
    fbc, opline->extended_value, obj);
18419
25
  call->prev_execute_data = EX(call);
18420
25
  EX(call) = call;
18421
18422
25
  ZEND_VM_NEXT_OPCODE();
18423
25
}
18424
18425
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18426
0
{
18427
0
  USE_OPLINE
18428
0
  zval *op1, *op2;
18429
0
  double d1, d2;
18430
18431
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18432
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18433
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
18434
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
18435
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
18436
0
case_true:
18437
0
        ZEND_VM_SMART_BRANCH_TRUE();
18438
0
      } else {
18439
0
case_false:
18440
0
        ZEND_VM_SMART_BRANCH_FALSE();
18441
0
      }
18442
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
18443
0
      d1 = (double)Z_LVAL_P(op1);
18444
0
      d2 = Z_DVAL_P(op2);
18445
0
      goto case_double;
18446
0
    }
18447
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
18448
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
18449
0
      d1 = Z_DVAL_P(op1);
18450
0
      d2 = Z_DVAL_P(op2);
18451
0
case_double:
18452
0
      if (d1 == d2) {
18453
0
        goto case_true;
18454
0
      } else {
18455
0
        goto case_false;
18456
0
      }
18457
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
18458
0
      d1 = Z_DVAL_P(op1);
18459
0
      d2 = (double)Z_LVAL_P(op2);
18460
0
      goto case_double;
18461
0
    }
18462
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18463
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18464
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
18465
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18466
0
      if (result) {
18467
0
        goto case_true;
18468
0
      } else {
18469
0
        goto case_false;
18470
0
      }
18471
0
    }
18472
0
  }
18473
0
  ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
18474
0
}
18475
18476
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18477
22
{
18478
22
  USE_OPLINE
18479
22
  zval *container;
18480
22
  bool result;
18481
22
  zend_ulong hval;
18482
22
  zval *offset;
18483
18484
22
  SAVE_OPLINE();
18485
22
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18486
22
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18487
18488
22
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18489
20
    HashTable *ht;
18490
20
    zval *value;
18491
20
    zend_string *str;
18492
18493
20
isset_dim_obj_array:
18494
20
    ht = Z_ARRVAL_P(container);
18495
20
isset_again:
18496
20
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
18497
0
      str = Z_STR_P(offset);
18498
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18499
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
18500
0
          goto num_index_prop;
18501
0
        }
18502
0
      }
18503
0
      value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18504
20
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
18505
17
      hval = Z_LVAL_P(offset);
18506
17
num_index_prop:
18507
17
      value = zend_hash_index_find(ht, hval);
18508
17
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
18509
0
      offset = Z_REFVAL_P(offset);
18510
0
      goto isset_again;
18511
3
    } else {
18512
3
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
18513
3
      if (UNEXPECTED(EG(exception))) {
18514
0
        result = 0;
18515
0
        goto isset_dim_obj_exit;
18516
0
      }
18517
3
    }
18518
18519
20
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
18520
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
18521
20
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
18522
20
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
18523
18524
20
      if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
18525
        /* avoid exception check */
18526
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18527
0
        ZEND_VM_SMART_BRANCH(result, 0);
18528
0
      }
18529
20
    } else {
18530
0
      result = (value == NULL || !i_zend_is_true(value));
18531
0
    }
18532
20
    goto isset_dim_obj_exit;
18533
20
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
18534
0
    container = Z_REFVAL_P(container);
18535
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18536
0
      goto isset_dim_obj_array;
18537
0
    }
18538
0
  }
18539
18540
2
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
18541
0
    offset++;
18542
0
  }
18543
2
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
18544
2
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
18545
2
  } else {
18546
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
18547
0
  }
18548
18549
22
isset_dim_obj_exit:
18550
22
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18551
22
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18552
22
  ZEND_VM_SMART_BRANCH(result, 1);
18553
22
}
18554
18555
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18556
19
{
18557
19
  USE_OPLINE
18558
19
  zval *container;
18559
19
  int result;
18560
19
  zval *offset;
18561
19
  zend_string *name, *tmp_name;
18562
18563
19
  SAVE_OPLINE();
18564
19
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18565
19
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18566
18567
19
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18568
19
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18569
19
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18570
0
      container = Z_REFVAL_P(container);
18571
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
18572
0
        result = (opline->extended_value & ZEND_ISEMPTY);
18573
0
        goto isset_object_finish;
18574
0
      }
18575
19
    } else {
18576
19
      result = (opline->extended_value & ZEND_ISEMPTY);
18577
19
      goto isset_object_finish;
18578
19
    }
18579
19
  }
18580
18581
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18582
0
    name = Z_STR_P(offset);
18583
0
  } else {
18584
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
18585
0
    if (UNEXPECTED(!name)) {
18586
0
      result = 0;
18587
0
      goto isset_object_finish;
18588
0
    }
18589
0
  }
18590
18591
0
  result =
18592
0
    (opline->extended_value & ZEND_ISEMPTY) ^
18593
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));
18594
18595
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18596
0
    zend_tmp_string_release(tmp_name);
18597
0
  }
18598
18599
19
isset_object_finish:
18600
19
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18601
19
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18602
19
  ZEND_VM_SMART_BRANCH(result, 1);
18603
19
}
18604
18605
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18606
0
{
18607
0
  USE_OPLINE
18608
18609
0
  zval *key, *subject;
18610
0
  HashTable *ht;
18611
0
  bool result;
18612
18613
0
  SAVE_OPLINE();
18614
18615
0
  key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18616
0
  subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18617
18618
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
18619
0
array_key_exists_array:
18620
0
    ht = Z_ARRVAL_P(subject);
18621
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
18622
0
  } else {
18623
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
18624
0
      subject = Z_REFVAL_P(subject);
18625
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
18626
0
        goto array_key_exists_array;
18627
0
      }
18628
0
    }
18629
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
18630
0
    result = 0;
18631
0
  }
18632
18633
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18634
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18635
0
  ZEND_VM_SMART_BRANCH(result, 1);
18636
0
}
18637
18638
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18639
5
{
18640
5
  USE_OPLINE
18641
5
  zval *expr;
18642
5
  bool result;
18643
18644
5
  SAVE_OPLINE();
18645
5
  expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18646
18647
5
try_instanceof:
18648
5
  if (Z_TYPE_P(expr) == IS_OBJECT) {
18649
5
    zend_class_entry *ce;
18650
18651
5
    if (IS_VAR == IS_CONST) {
18652
0
      ce = CACHED_PTR(opline->extended_value);
18653
0
      if (UNEXPECTED(ce == NULL)) {
18654
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);
18655
0
        if (EXPECTED(ce)) {
18656
0
          CACHE_PTR(opline->extended_value, ce);
18657
0
        }
18658
0
      }
18659
5
    } else if (IS_VAR == IS_UNUSED) {
18660
0
      ce = zend_fetch_class(NULL, opline->op2.num);
18661
0
      if (UNEXPECTED(ce == NULL)) {
18662
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18663
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
18664
0
        HANDLE_EXCEPTION();
18665
0
      }
18666
5
    } else {
18667
5
      ce = Z_CE_P(EX_VAR(opline->op2.var));
18668
5
    }
18669
5
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18670
5
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18671
0
    expr = Z_REFVAL_P(expr);
18672
0
    goto try_instanceof;
18673
0
  } else {
18674
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18675
0
      ZVAL_UNDEFINED_OP1();
18676
0
    }
18677
0
    result = 0;
18678
0
  }
18679
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18680
5
  ZEND_VM_SMART_BRANCH(result, 1);
18681
5
}
18682
18683
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)
18684
18.8k
{
18685
18.8k
  USE_OPLINE
18686
18.8k
  zval *varname;
18687
18.8k
  zval *retval;
18688
18.8k
  zend_string *name, *tmp_name;
18689
18.8k
  HashTable *target_symbol_table;
18690
18691
18.8k
  SAVE_OPLINE();
18692
18.8k
  varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18693
18694
18.8k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18695
0
    name = Z_STR_P(varname);
18696
18.8k
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18697
4.40k
    name = Z_STR_P(varname);
18698
4.40k
    tmp_name = NULL;
18699
14.4k
  } else {
18700
14.4k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18701
0
      ZVAL_UNDEFINED_OP1();
18702
0
    }
18703
14.4k
    name = zval_try_get_tmp_string(varname, &tmp_name);
18704
14.4k
    if (UNEXPECTED(!name)) {
18705
17
      if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18706
12
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18707
12
      }
18708
17
      ZVAL_UNDEF(EX_VAR(opline->result.var));
18709
17
      HANDLE_EXCEPTION();
18710
17
    }
18711
14.4k
  }
18712
18713
18.8k
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18714
18.8k
  retval = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18715
18.8k
  if (retval == NULL) {
18716
13.6k
    if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18717
0
fetch_this:
18718
0
      zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
18719
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18720
0
        zend_tmp_string_release(tmp_name);
18721
0
      }
18722
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18723
0
    }
18724
13.6k
    if (type == BP_VAR_W) {
18725
2.95k
      retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
18726
10.6k
    } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18727
0
      retval = &EG(uninitialized_zval);
18728
10.6k
    } else {
18729
10.6k
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18730
        /* Keep name alive in case an error handler tries to free it. */
18731
0
        zend_string_addref(name);
18732
0
      }
18733
10.6k
      zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18734
10.6k
        (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18735
10.6k
      if (type == BP_VAR_RW && !EG(exception)) {
18736
107
        retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
18737
10.5k
      } else {
18738
10.5k
        retval = &EG(uninitialized_zval);
18739
10.5k
      }
18740
10.6k
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18741
0
        zend_string_release(name);
18742
0
      }
18743
10.6k
    }
18744
  /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
18745
13.6k
  } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
18746
151
    retval = Z_INDIRECT_P(retval);
18747
151
    if (Z_TYPE_P(retval) == IS_UNDEF) {
18748
24
      if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18749
0
        goto fetch_this;
18750
0
      }
18751
24
      if (type == BP_VAR_W) {
18752
10
        ZVAL_NULL(retval);
18753
14
      } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18754
0
        retval = &EG(uninitialized_zval);
18755
14
      } else {
18756
14
        zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18757
14
          (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18758
14
        if (type == BP_VAR_RW && !EG(exception)) {
18759
0
          ZVAL_NULL(retval);
18760
14
        } else {
18761
14
          retval = &EG(uninitialized_zval);
18762
14
        }
18763
14
      }
18764
24
    }
18765
151
  }
18766
18767
18.8k
  if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18768
18.8k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18769
18.8k
  }
18770
18771
18.8k
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18772
18.8k
    zend_tmp_string_release(tmp_name);
18773
18.8k
  }
18774
18775
18.8k
  ZEND_ASSERT(retval != NULL);
18776
18.8k
  if (type == BP_VAR_R || type == BP_VAR_IS) {
18777
13.8k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18778
13.8k
  } else {
18779
4.93k
    ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
18780
4.93k
  }
18781
18.8k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18782
18.8k
}
18783
18784
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18785
13.7k
{
18786
13.7k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R));
18787
13.7k
}
18788
18789
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18790
3.49k
{
18791
3.49k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W));
18792
3.49k
}
18793
18794
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18795
1.44k
{
18796
1.44k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW));
18797
1.44k
}
18798
18799
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18800
128
{
18801
128
  int fetch_type =
18802
128
    (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
18803
128
      BP_VAR_W : BP_VAR_R;
18804
128
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type));
18805
128
}
18806
18807
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18808
0
{
18809
0
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET));
18810
0
}
18811
18812
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18813
2
{
18814
2
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS));
18815
2
}
18816
18817
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
18818
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18819
117k
{
18820
117k
  USE_OPLINE
18821
117k
  zval *value, *arg;
18822
18823
117k
  if (IS_UNUSED == IS_CONST) {
18824
0
    SAVE_OPLINE();
18825
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
18826
0
    uint32_t arg_num;
18827
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
18828
0
    if (UNEXPECTED(!arg)) {
18829
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18830
0
      HANDLE_EXCEPTION();
18831
0
    }
18832
117k
  } else {
18833
117k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
18834
117k
  }
18835
18836
117k
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18837
117k
  ZVAL_COPY_VALUE(arg, value);
18838
117k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18839
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
18840
0
      Z_ADDREF_P(arg);
18841
0
    }
18842
0
  }
18843
117k
  ZEND_VM_NEXT_OPCODE();
18844
117k
}
18845
18846
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18847
5
{
18848
5
  USE_OPLINE
18849
5
  zval *varname;
18850
5
  zend_string *name, *tmp_name;
18851
5
  HashTable *target_symbol_table;
18852
18853
5
  SAVE_OPLINE();
18854
18855
5
  varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18856
18857
5
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18858
0
    name = Z_STR_P(varname);
18859
5
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18860
5
    name = Z_STR_P(varname);
18861
5
    tmp_name = NULL;
18862
5
  } else {
18863
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18864
0
      varname = ZVAL_UNDEFINED_OP1();
18865
0
    }
18866
0
    name = zval_try_get_tmp_string(varname, &tmp_name);
18867
0
    if (UNEXPECTED(!name)) {
18868
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18869
0
      HANDLE_EXCEPTION();
18870
0
    }
18871
0
  }
18872
18873
5
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18874
5
  zend_hash_del_ind(target_symbol_table, name);
18875
18876
5
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18877
5
    zend_tmp_string_release(tmp_name);
18878
5
  }
18879
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18880
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18881
5
}
18882
18883
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
18884
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18885
5
{
18886
5
  USE_OPLINE
18887
5
  zval *value;
18888
5
  bool result;
18889
5
  zval *varname;
18890
5
  zend_string *name, *tmp_name;
18891
5
  HashTable *target_symbol_table;
18892
18893
5
  SAVE_OPLINE();
18894
5
  varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18895
5
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18896
0
    name = Z_STR_P(varname);
18897
5
  } else {
18898
5
    name = zval_get_tmp_string(varname, &tmp_name);
18899
5
  }
18900
18901
5
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18902
5
  value = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18903
18904
5
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18905
5
    zend_tmp_string_release(tmp_name);
18906
5
  }
18907
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18908
18909
5
  if (!value) {
18910
5
    result = (opline->extended_value & ZEND_ISEMPTY);
18911
5
  } else {
18912
0
    if (Z_TYPE_P(value) == IS_INDIRECT) {
18913
0
      value = Z_INDIRECT_P(value);
18914
0
    }
18915
0
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
18916
0
      if (Z_ISREF_P(value)) {
18917
0
        value = Z_REFVAL_P(value);
18918
0
      }
18919
0
      result = Z_TYPE_P(value) > IS_NULL;
18920
0
    } else {
18921
0
      result = !i_zend_is_true(value);
18922
0
    }
18923
0
  }
18924
18925
5
  ZEND_VM_SMART_BRANCH(result, true);
18926
5
}
18927
18928
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
18929
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18930
5
{
18931
5
  USE_OPLINE
18932
5
  zval *expr;
18933
5
  bool result;
18934
18935
5
  SAVE_OPLINE();
18936
5
  expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18937
18938
5
try_instanceof:
18939
5
  if (Z_TYPE_P(expr) == IS_OBJECT) {
18940
5
    zend_class_entry *ce;
18941
18942
5
    if (IS_UNUSED == IS_CONST) {
18943
0
      ce = CACHED_PTR(opline->extended_value);
18944
0
      if (UNEXPECTED(ce == NULL)) {
18945
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);
18946
0
        if (EXPECTED(ce)) {
18947
0
          CACHE_PTR(opline->extended_value, ce);
18948
0
        }
18949
0
      }
18950
5
    } else if (IS_UNUSED == IS_UNUSED) {
18951
5
      ce = zend_fetch_class(NULL, opline->op2.num);
18952
5
      if (UNEXPECTED(ce == NULL)) {
18953
5
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18954
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
18955
5
        HANDLE_EXCEPTION();
18956
5
      }
18957
5
    } else {
18958
0
      ce = Z_CE_P(EX_VAR(opline->op2.var));
18959
0
    }
18960
0
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18961
0
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18962
0
    expr = Z_REFVAL_P(expr);
18963
0
    goto try_instanceof;
18964
0
  } else {
18965
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18966
0
      ZVAL_UNDEFINED_OP1();
18967
0
    }
18968
0
    result = 0;
18969
0
  }
18970
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18971
0
  ZEND_VM_SMART_BRANCH(result, 1);
18972
0
}
18973
18974
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18975
162
{
18976
162
  USE_OPLINE
18977
162
  zval *op1;
18978
162
  zend_long count;
18979
18980
162
  SAVE_OPLINE();
18981
162
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18982
18983
162
  while (1) {
18984
162
    if (Z_TYPE_P(op1) == IS_ARRAY) {
18985
159
      count = zend_hash_num_elements(Z_ARRVAL_P(op1));
18986
159
      break;
18987
159
    } else if (Z_TYPE_P(op1) == IS_OBJECT) {
18988
0
      zend_object *zobj = Z_OBJ_P(op1);
18989
18990
      /* first, we check if the handler is defined */
18991
0
      if (zobj->handlers->count_elements) {
18992
0
        if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
18993
0
          break;
18994
0
        }
18995
0
        if (UNEXPECTED(EG(exception))) {
18996
0
          count = 0;
18997
0
          break;
18998
0
        }
18999
0
      }
19000
19001
      /* if not and the object implements Countable we call its count() method */
19002
0
      if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
19003
0
        zval retval;
19004
19005
0
        zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
19006
0
        zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
19007
0
        count = zval_get_long(&retval);
19008
0
        zval_ptr_dtor(&retval);
19009
0
        break;
19010
0
      }
19011
19012
      /* If There's no handler and it doesn't implement Countable then emit a TypeError */
19013
3
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
19014
0
      op1 = Z_REFVAL_P(op1);
19015
0
      continue;
19016
3
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19017
0
      ZVAL_UNDEFINED_OP1();
19018
0
    }
19019
3
    count = 0;
19020
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));
19021
3
    break;
19022
162
  }
19023
19024
162
  ZVAL_LONG(EX_VAR(opline->result.var), count);
19025
162
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19026
162
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19027
162
}
19028
19029
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19030
49
{
19031
49
  USE_OPLINE
19032
49
  zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC));
19033
49
  ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
19034
49
  if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
19035
42
    SAVE_OPLINE();
19036
42
    zend_array_destroy(ht);
19037
42
    if (EG(exception)) {
19038
35
      HANDLE_EXCEPTION();
19039
35
    }
19040
42
  }
19041
14
  ZEND_VM_NEXT_OPCODE();
19042
14
}
19043
19044
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19045
293
{
19046
293
  USE_OPLINE
19047
19048
293
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
19049
0
    SAVE_OPLINE();
19050
0
    if (UNEXPECTED(!EX(func)->common.scope)) {
19051
0
      zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
19052
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
19053
0
      HANDLE_EXCEPTION();
19054
0
    } else {
19055
0
      zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
19056
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
19057
0
      if (UNEXPECTED(EG(exception))) {
19058
0
        HANDLE_EXCEPTION();
19059
0
      }
19060
0
      ZEND_VM_NEXT_OPCODE();
19061
0
    }
19062
293
  } else {
19063
293
    zval *op1;
19064
19065
293
    SAVE_OPLINE();
19066
293
    op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19067
293
    while (1) {
19068
293
      if (Z_TYPE_P(op1) == IS_OBJECT) {
19069
286
        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
19070
286
      } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
19071
0
        op1 = Z_REFVAL_P(op1);
19072
0
        continue;
19073
7
      } else {
19074
7
        if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19075
0
          ZVAL_UNDEFINED_OP1();
19076
0
        }
19077
7
        zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
19078
7
        ZVAL_UNDEF(EX_VAR(opline->result.var));
19079
7
      }
19080
293
      break;
19081
293
    }
19082
293
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19083
293
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19084
293
  }
19085
293
}
19086
19087
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19088
934
{
19089
934
  USE_OPLINE
19090
934
  zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19091
934
  zval *result = EX_VAR(opline->result.var);
19092
934
  ZVAL_COPY(result, value);
19093
934
  ZEND_VM_NEXT_OPCODE();
19094
934
}
19095
19096
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19097
0
{
19098
0
  USE_OPLINE
19099
0
  zval *op1, *op2;
19100
19101
0
  SAVE_OPLINE();
19102
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19103
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19104
0
  div_function(EX_VAR(opline->result.var), op1, op2);
19105
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19106
19107
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19108
0
}
19109
19110
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19111
0
{
19112
0
  USE_OPLINE
19113
0
  zval *op1, *op2;
19114
19115
0
  SAVE_OPLINE();
19116
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19117
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19118
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
19119
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19120
19121
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19122
0
}
19123
19124
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19125
1.15k
{
19126
1.15k
  USE_OPLINE
19127
1.15k
  zval *op1, *op2;
19128
19129
1.15k
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19130
1.15k
  op2 = EX_VAR(opline->op2.var);
19131
19132
1.15k
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
19133
1.15k
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
19134
864
    zend_string *op1_str = Z_STR_P(op1);
19135
864
    zend_string *op2_str = Z_STR_P(op2);
19136
864
    zend_string *str;
19137
864
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
19138
19139
864
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19140
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
19141
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
19142
0
      } else {
19143
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19144
0
      }
19145
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19146
0
        zend_string_release_ex(op1_str, 0);
19147
0
      }
19148
864
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19149
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
19150
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
19151
0
      } else {
19152
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19153
0
      }
19154
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19155
0
        zend_string_release_ex(op2_str, 0);
19156
0
      }
19157
864
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
19158
864
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
19159
852
      size_t len = ZSTR_LEN(op1_str);
19160
19161
852
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
19162
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
19163
0
      }
19164
852
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
19165
852
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19166
852
      GC_ADD_FLAGS(str, flags);
19167
852
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19168
852
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19169
0
        zend_string_release_ex(op2_str, 0);
19170
0
      }
19171
852
    } else {
19172
12
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19173
12
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19174
12
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19175
12
      GC_ADD_FLAGS(str, flags);
19176
12
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19177
12
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19178
12
        zend_string_release_ex(op1_str, 0);
19179
12
      }
19180
12
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19181
0
        zend_string_release_ex(op2_str, 0);
19182
0
      }
19183
12
    }
19184
864
    ZEND_VM_NEXT_OPCODE();
19185
864
  } else {
19186
293
    SAVE_OPLINE();
19187
19188
293
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19189
0
      op1 = ZVAL_UNDEFINED_OP1();
19190
0
    }
19191
293
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
19192
138
      op2 = ZVAL_UNDEFINED_OP2();
19193
138
    }
19194
293
    concat_function(EX_VAR(opline->result.var), op1, op2);
19195
293
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19196
19197
293
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19198
293
  }
19199
1.15k
}
19200
19201
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19202
4
{
19203
4
  USE_OPLINE
19204
4
  zval *op1, *op2;
19205
19206
4
  SAVE_OPLINE();
19207
4
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19208
4
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19209
4
  compare_function(EX_VAR(opline->result.var), op1, op2);
19210
4
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19211
19212
4
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19213
4
}
19214
19215
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19216
666
{
19217
666
  USE_OPLINE
19218
666
  zval *container, *dim, *value;
19219
19220
666
  SAVE_OPLINE();
19221
666
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19222
666
  dim = EX_VAR(opline->op2.var);
19223
666
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19224
666
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19225
471
fetch_dim_r_array:
19226
471
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
19227
471
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
19228
471
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
19229
0
      container = Z_REFVAL_P(container);
19230
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19231
0
        goto fetch_dim_r_array;
19232
0
      } else {
19233
0
        goto fetch_dim_r_slow;
19234
0
      }
19235
195
    } else {
19236
195
fetch_dim_r_slow:
19237
195
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
19238
0
        dim++;
19239
0
      }
19240
195
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
19241
195
    }
19242
666
  } else {
19243
0
    zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
19244
0
  }
19245
19246
666
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19247
666
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19248
666
}
19249
19250
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19251
0
{
19252
0
  USE_OPLINE
19253
0
  zval *container;
19254
19255
0
  SAVE_OPLINE();
19256
0
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19257
0
  zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
19258
19259
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19260
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19261
0
}
19262
19263
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19264
0
{
19265
0
  USE_OPLINE
19266
0
  zval *container;
19267
0
  void **cache_slot = NULL;
19268
19269
0
  SAVE_OPLINE();
19270
0
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19271
19272
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19273
0
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19274
0
    do {
19275
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19276
0
        container = Z_REFVAL_P(container);
19277
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
19278
0
          break;
19279
0
        }
19280
0
      }
19281
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
19282
0
        ZVAL_UNDEFINED_OP1();
19283
0
      }
19284
0
      zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19285
0
      ZVAL_NULL(EX_VAR(opline->result.var));
19286
0
      goto fetch_obj_r_finish;
19287
0
    } while (0);
19288
0
  }
19289
19290
  /* here we are sure we are dealing with an object */
19291
0
  do {
19292
0
    zend_object *zobj = Z_OBJ_P(container);
19293
0
    zend_string *name, *tmp_name;
19294
0
    zval *retval;
19295
19296
0
    if (IS_CV == IS_CONST) {
19297
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
19298
19299
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
19300
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
19301
19302
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
19303
0
fetch_obj_r_simple:
19304
0
          retval = OBJ_PROP(zobj, prop_offset);
19305
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
19306
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19307
0
              goto fetch_obj_r_copy;
19308
0
            } else {
19309
0
fetch_obj_r_fast_copy:
19310
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19311
0
              ZEND_VM_NEXT_OPCODE();
19312
0
            }
19313
0
          }
19314
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
19315
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
19316
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
19317
0
            prop_offset = prop_info->offset;
19318
0
            goto fetch_obj_r_simple;
19319
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
19320
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
19321
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
19322
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
19323
19324
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19325
0
            if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
19326
0
              GC_ADDREF(zobj);
19327
0
            }
19328
0
            if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
19329
0
              call_info |= ZEND_CALL_RELEASE_THIS;
19330
0
            }
19331
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
19332
0
            call->prev_execute_data = execute_data;
19333
0
            call->call = NULL;
19334
0
            call->return_value = EX_VAR(opline->result.var);
19335
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
19336
19337
0
            execute_data = call;
19338
0
            EG(current_execute_data) = execute_data;
19339
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
19340
19341
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
19342
            opline = hook->op_array.opcodes;
19343
#else
19344
0
            EX(opline) = hook->op_array.opcodes;
19345
0
#endif
19346
0
            LOAD_OPLINE_EX();
19347
19348
19349
0
            ZEND_VM_ENTER_EX();
19350
0
          }
19351
          /* Fall through to read_property for hooks. */
19352
0
        } else if (EXPECTED(zobj->properties != NULL)) {
19353
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
19354
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19355
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
19356
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
19357
19358
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
19359
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
19360
19361
0
              if (EXPECTED(p->key == name) ||
19362
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
19363
0
                   EXPECTED(p->key != NULL) &&
19364
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
19365
0
                retval = &p->val;
19366
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19367
0
                  goto fetch_obj_r_copy;
19368
0
                } else {
19369
0
                  goto fetch_obj_r_fast_copy;
19370
0
                }
19371
0
              }
19372
0
            }
19373
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
19374
0
          }
19375
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
19376
0
          if (EXPECTED(retval)) {
19377
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
19378
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
19379
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19380
0
              goto fetch_obj_r_copy;
19381
0
            } else {
19382
0
              goto fetch_obj_r_fast_copy;
19383
0
            }
19384
0
          }
19385
0
        }
19386
0
      }
19387
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19388
0
    } else {
19389
0
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
19390
0
      if (UNEXPECTED(!name)) {
19391
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
19392
0
        break;
19393
0
      }
19394
0
    }
19395
19396
0
#if ZEND_DEBUG
19397
    /* For non-standard object handlers, verify a declared property type in debug builds.
19398
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
19399
0
    zend_property_info *prop_info = NULL;
19400
0
    if (zobj->handlers->read_property != zend_std_read_property) {
19401
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
19402
0
    }
19403
0
#endif
19404
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
19405
0
#if ZEND_DEBUG
19406
0
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
19407
0
        && ZEND_TYPE_IS_SET(prop_info->type)) {
19408
0
      ZVAL_OPT_DEREF(retval);
19409
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
19410
0
    }
19411
0
#endif
19412
19413
0
    if (IS_CV != IS_CONST) {
19414
0
      zend_tmp_string_release(tmp_name);
19415
0
    }
19416
19417
0
    if (retval != EX_VAR(opline->result.var)) {
19418
0
fetch_obj_r_copy:
19419
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19420
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
19421
0
      zend_unwrap_reference(retval);
19422
0
    }
19423
0
  } while (0);
19424
19425
0
fetch_obj_r_finish:
19426
19427
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19428
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19429
0
}
19430
19431
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19432
0
{
19433
0
  USE_OPLINE
19434
0
  zval *container;
19435
0
  void **cache_slot = NULL;
19436
19437
0
  SAVE_OPLINE();
19438
0
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19439
19440
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19441
0
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19442
0
    do {
19443
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19444
0
        container = Z_REFVAL_P(container);
19445
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
19446
0
          break;
19447
0
        }
19448
0
      }
19449
0
      if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
19450
0
        ZVAL_UNDEFINED_OP2();
19451
0
      }
19452
0
      ZVAL_NULL(EX_VAR(opline->result.var));
19453
0
      goto fetch_obj_is_finish;
19454
0
    } while (0);
19455
0
  }
19456
19457
  /* here we are sure we are dealing with an object */
19458
0
  do {
19459
0
    zend_object *zobj = Z_OBJ_P(container);
19460
0
    zend_string *name, *tmp_name;
19461
0
    zval *retval;
19462
19463
0
    if (IS_CV == IS_CONST) {
19464
0
      cache_slot = CACHE_ADDR(opline->extended_value);
19465
19466
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
19467
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
19468
19469
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
19470
0
fetch_obj_is_simple:
19471
0
          retval = OBJ_PROP(zobj, prop_offset);
19472
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
19473
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19474
0
              goto fetch_obj_is_copy;
19475
0
            } else {
19476
0
fetch_obj_is_fast_copy:
19477
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19478
0
              ZEND_VM_NEXT_OPCODE();
19479
0
            }
19480
0
          }
19481
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
19482
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
19483
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
19484
0
            prop_offset = prop_info->offset;
19485
0
            goto fetch_obj_is_simple;
19486
0
          }
19487
          /* Fall through to read_property for hooks. */
19488
0
        } else if (EXPECTED(zobj->properties != NULL)) {
19489
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
19490
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19491
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
19492
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
19493
19494
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
19495
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
19496
19497
0
              if (EXPECTED(p->key == name) ||
19498
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
19499
0
                   EXPECTED(p->key != NULL) &&
19500
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
19501
0
                retval = &p->val;
19502
0
                if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19503
0
                  goto fetch_obj_is_copy;
19504
0
                } else {
19505
0
                  goto fetch_obj_is_fast_copy;
19506
0
                }
19507
0
              }
19508
0
            }
19509
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
19510
0
          }
19511
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
19512
0
          if (EXPECTED(retval)) {
19513
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
19514
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
19515
0
            if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19516
0
              goto fetch_obj_is_copy;
19517
0
            } else {
19518
0
              goto fetch_obj_is_fast_copy;
19519
0
            }
19520
0
          }
19521
0
        }
19522
0
      }
19523
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19524
0
    } else {
19525
0
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
19526
0
      if (UNEXPECTED(!name)) {
19527
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
19528
0
        break;
19529
0
      }
19530
0
    }
19531
19532
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
19533
19534
0
    if (IS_CV != IS_CONST) {
19535
0
      zend_tmp_string_release(tmp_name);
19536
0
    }
19537
19538
0
    if (retval != EX_VAR(opline->result.var)) {
19539
0
fetch_obj_is_copy:
19540
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19541
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
19542
0
      zend_unwrap_reference(retval);
19543
0
    }
19544
0
  } while (0);
19545
19546
0
fetch_obj_is_finish:
19547
19548
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19549
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19550
0
}
19551
19552
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19553
170
{
19554
170
  USE_OPLINE
19555
170
  zval *op1, *op2;
19556
170
  zend_string *op1_str, *op2_str, *str;
19557
19558
19559
170
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19560
170
  op2 = EX_VAR(opline->op2.var);
19561
170
  if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
19562
170
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
19563
40
    zend_string *op1_str = Z_STR_P(op1);
19564
40
    zend_string *op2_str = Z_STR_P(op2);
19565
40
    zend_string *str;
19566
40
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
19567
19568
40
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19569
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
19570
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
19571
0
      } else {
19572
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19573
0
      }
19574
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19575
0
        zend_string_release_ex(op1_str, 0);
19576
0
      }
19577
40
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19578
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
19579
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
19580
0
      } else {
19581
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19582
0
      }
19583
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19584
0
        zend_string_release_ex(op2_str, 0);
19585
0
      }
19586
40
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
19587
40
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
19588
37
      size_t len = ZSTR_LEN(op1_str);
19589
19590
37
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
19591
37
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19592
37
      GC_ADD_FLAGS(str, flags);
19593
37
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19594
37
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19595
0
        zend_string_release_ex(op2_str, 0);
19596
0
      }
19597
37
    } else {
19598
3
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19599
3
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19600
3
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19601
3
      GC_ADD_FLAGS(str, flags);
19602
3
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19603
3
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19604
3
        zend_string_release_ex(op1_str, 0);
19605
3
      }
19606
3
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19607
0
        zend_string_release_ex(op2_str, 0);
19608
0
      }
19609
3
    }
19610
40
    ZEND_VM_NEXT_OPCODE();
19611
40
  }
19612
19613
170
  SAVE_OPLINE();
19614
130
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
19615
0
    op1_str = Z_STR_P(op1);
19616
130
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19617
130
    op1_str = zend_string_copy(Z_STR_P(op1));
19618
130
  } else {
19619
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19620
0
      ZVAL_UNDEFINED_OP1();
19621
0
    }
19622
0
    op1_str = zval_get_string_func(op1);
19623
0
  }
19624
130
  if (IS_CV == IS_CONST) {
19625
0
    op2_str = Z_STR_P(op2);
19626
130
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19627
0
    op2_str = zend_string_copy(Z_STR_P(op2));
19628
130
  } else {
19629
130
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
19630
130
      ZVAL_UNDEFINED_OP2();
19631
130
    }
19632
130
    op2_str = zval_get_string_func(op2);
19633
130
  }
19634
130
  do {
19635
130
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19636
130
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19637
125
        if (IS_CV == IS_CONST) {
19638
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
19639
0
            GC_ADDREF(op2_str);
19640
0
          }
19641
0
        }
19642
125
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19643
125
        zend_string_release_ex(op1_str, 0);
19644
125
        break;
19645
125
      }
19646
130
    }
19647
5
    if (IS_CV != IS_CONST) {
19648
5
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19649
5
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
19650
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
19651
0
            GC_ADDREF(op1_str);
19652
0
          }
19653
0
        }
19654
5
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19655
5
        zend_string_release_ex(op2_str, 0);
19656
5
        break;
19657
5
      }
19658
5
    }
19659
0
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19660
0
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19661
0
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19662
19663
0
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
19664
0
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19665
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19666
0
      zend_string_release_ex(op1_str, 0);
19667
0
    }
19668
0
    if (IS_CV != IS_CONST) {
19669
0
      zend_string_release_ex(op2_str, 0);
19670
0
    }
19671
0
  } while (0);
19672
130
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19673
19674
130
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19675
130
}
19676
19677
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19678
130
{
19679
130
  USE_OPLINE
19680
130
  zval *function_name;
19681
130
  zval *object;
19682
130
  zend_function *fbc;
19683
130
  zend_class_entry *called_scope;
19684
130
  zend_object *obj;
19685
130
  zend_execute_data *call;
19686
130
  uint32_t call_info;
19687
19688
130
  SAVE_OPLINE();
19689
19690
130
  object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19691
19692
130
  if (IS_CV != IS_CONST) {
19693
130
    function_name = EX_VAR(opline->op2.var);
19694
130
  }
19695
19696
130
  if (IS_CV != IS_CONST &&
19697
130
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
19698
0
    do {
19699
0
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
19700
0
        function_name = Z_REFVAL_P(function_name);
19701
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
19702
0
          break;
19703
0
        }
19704
0
      } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
19705
0
        ZVAL_UNDEFINED_OP2();
19706
0
        if (UNEXPECTED(EG(exception) != NULL)) {
19707
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19708
0
          HANDLE_EXCEPTION();
19709
0
        }
19710
0
      }
19711
0
      zend_throw_error(NULL, "Method name must be a string");
19712
19713
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19714
0
      HANDLE_EXCEPTION();
19715
0
    } while (0);
19716
0
  }
19717
19718
130
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
19719
0
    obj = Z_OBJ_P(object);
19720
130
  } else {
19721
130
    do {
19722
130
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19723
130
        obj = Z_OBJ_P(object);
19724
130
      } else {
19725
0
        if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
19726
0
          zend_reference *ref = Z_REF_P(object);
19727
19728
0
          object = &ref->val;
19729
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19730
0
            obj = Z_OBJ_P(object);
19731
0
            if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
19732
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19733
0
                efree_size(ref, sizeof(zend_reference));
19734
0
              } else {
19735
0
                Z_ADDREF_P(object);
19736
0
              }
19737
0
            }
19738
0
            break;
19739
0
          }
19740
0
        }
19741
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
19742
0
          object = ZVAL_UNDEFINED_OP1();
19743
0
          if (UNEXPECTED(EG(exception) != NULL)) {
19744
0
            if (IS_CV != IS_CONST) {
19745
19746
0
            }
19747
0
            HANDLE_EXCEPTION();
19748
0
          }
19749
0
        }
19750
0
        if (IS_CV == IS_CONST) {
19751
0
          function_name = EX_VAR(opline->op2.var);
19752
0
        }
19753
0
        zend_invalid_method_call(object, function_name);
19754
19755
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19756
0
        HANDLE_EXCEPTION();
19757
0
      }
19758
130
    } while (0);
19759
130
  }
19760
19761
130
  called_scope = obj->ce;
19762
19763
130
  if (IS_CV == IS_CONST &&
19764
130
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
19765
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
19766
130
  } else {
19767
130
    zend_object *orig_obj = obj;
19768
19769
130
    if (IS_CV == IS_CONST) {
19770
0
      function_name = EX_VAR(opline->op2.var);
19771
0
    }
19772
19773
    /* First, locate the function. */
19774
130
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
19775
130
    if (UNEXPECTED(fbc == NULL)) {
19776
2
      if (EXPECTED(!EG(exception))) {
19777
2
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
19778
2
      }
19779
19780
2
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
19781
0
        zend_objects_store_del(orig_obj);
19782
0
      }
19783
2
      HANDLE_EXCEPTION();
19784
2
    }
19785
128
    if (IS_CV == IS_CONST &&
19786
128
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
19787
128
        EXPECTED(obj == orig_obj)) {
19788
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
19789
0
    }
19790
128
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
19791
0
      GC_ADDREF(obj); /* For $this pointer */
19792
0
      if (GC_DELREF(orig_obj) == 0) {
19793
0
        zend_objects_store_del(orig_obj);
19794
0
      }
19795
0
    }
19796
128
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
19797
15
      init_func_run_time_cache(&fbc->op_array);
19798
15
    }
19799
128
  }
19800
19801
128
  if (IS_CV != IS_CONST) {
19802
19803
128
  }
19804
19805
128
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19806
128
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
19807
2
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
19808
2
      zend_objects_store_del(obj);
19809
2
      if (UNEXPECTED(EG(exception))) {
19810
0
        HANDLE_EXCEPTION();
19811
0
      }
19812
2
    }
19813
    /* call static method */
19814
2
    obj = (zend_object*)called_scope;
19815
2
    call_info = ZEND_CALL_NESTED_FUNCTION;
19816
126
  } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
19817
126
    if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
19818
0
      GC_ADDREF(obj); /* For $this pointer */
19819
0
    }
19820
    /* CV may be changed indirectly (e.g. when it's a reference) */
19821
126
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
19822
126
  }
19823
19824
128
  call = zend_vm_stack_push_call_frame(call_info,
19825
128
    fbc, opline->extended_value, obj);
19826
128
  call->prev_execute_data = EX(call);
19827
128
  EX(call) = call;
19828
19829
128
  ZEND_VM_NEXT_OPCODE();
19830
128
}
19831
19832
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19833
0
{
19834
0
  USE_OPLINE
19835
0
  zval *op1, *op2;
19836
0
  double d1, d2;
19837
19838
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19839
0
  op2 = EX_VAR(opline->op2.var);
19840
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
19841
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19842
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
19843
0
case_true:
19844
0
        ZEND_VM_SMART_BRANCH_TRUE();
19845
0
      } else {
19846
0
case_false:
19847
0
        ZEND_VM_SMART_BRANCH_FALSE();
19848
0
      }
19849
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19850
0
      d1 = (double)Z_LVAL_P(op1);
19851
0
      d2 = Z_DVAL_P(op2);
19852
0
      goto case_double;
19853
0
    }
19854
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
19855
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19856
0
      d1 = Z_DVAL_P(op1);
19857
0
      d2 = Z_DVAL_P(op2);
19858
0
case_double:
19859
0
      if (d1 == d2) {
19860
0
        goto case_true;
19861
0
      } else {
19862
0
        goto case_false;
19863
0
      }
19864
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19865
0
      d1 = Z_DVAL_P(op1);
19866
0
      d2 = (double)Z_LVAL_P(op2);
19867
0
      goto case_double;
19868
0
    }
19869
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19870
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19871
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
19872
19873
0
      if (result) {
19874
0
        goto case_true;
19875
0
      } else {
19876
0
        goto case_false;
19877
0
      }
19878
0
    }
19879
0
  }
19880
0
  ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
19881
0
}
19882
19883
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19884
415
{
19885
415
  USE_OPLINE
19886
415
  zval *container;
19887
415
  bool result;
19888
415
  zend_ulong hval;
19889
415
  zval *offset;
19890
19891
415
  SAVE_OPLINE();
19892
415
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19893
415
  offset = EX_VAR(opline->op2.var);
19894
19895
415
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19896
213
    HashTable *ht;
19897
213
    zval *value;
19898
213
    zend_string *str;
19899
19900
213
isset_dim_obj_array:
19901
213
    ht = Z_ARRVAL_P(container);
19902
213
isset_again:
19903
213
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
19904
203
      str = Z_STR_P(offset);
19905
203
      if (IS_CV != IS_CONST) {
19906
203
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
19907
0
          goto num_index_prop;
19908
0
        }
19909
203
      }
19910
203
      value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
19911
203
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
19912
0
      hval = Z_LVAL_P(offset);
19913
0
num_index_prop:
19914
0
      value = zend_hash_index_find(ht, hval);
19915
10
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
19916
0
      offset = Z_REFVAL_P(offset);
19917
0
      goto isset_again;
19918
10
    } else {
19919
10
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
19920
10
      if (UNEXPECTED(EG(exception))) {
19921
0
        result = 0;
19922
0
        goto isset_dim_obj_exit;
19923
0
      }
19924
10
    }
19925
19926
213
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
19927
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
19928
199
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
19929
199
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
19930
19931
199
      if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
19932
        /* avoid exception check */
19933
19934
0
        ZEND_VM_SMART_BRANCH(result, 0);
19935
0
      }
19936
199
    } else {
19937
14
      result = (value == NULL || !i_zend_is_true(value));
19938
14
    }
19939
213
    goto isset_dim_obj_exit;
19940
213
  } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
19941
0
    container = Z_REFVAL_P(container);
19942
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19943
0
      goto isset_dim_obj_array;
19944
0
    }
19945
0
  }
19946
19947
202
  if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
19948
0
    offset++;
19949
0
  }
19950
202
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
19951
202
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
19952
202
  } else {
19953
0
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
19954
0
  }
19955
19956
415
isset_dim_obj_exit:
19957
19958
415
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19959
415
  ZEND_VM_SMART_BRANCH(result, 1);
19960
415
}
19961
19962
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19963
113
{
19964
113
  USE_OPLINE
19965
113
  zval *container;
19966
113
  int result;
19967
113
  zval *offset;
19968
113
  zend_string *name, *tmp_name;
19969
19970
113
  SAVE_OPLINE();
19971
113
  container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19972
113
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19973
19974
113
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19975
113
      ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19976
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19977
0
      container = Z_REFVAL_P(container);
19978
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
19979
0
        result = (opline->extended_value & ZEND_ISEMPTY);
19980
0
        goto isset_object_finish;
19981
0
      }
19982
0
    } else {
19983
0
      result = (opline->extended_value & ZEND_ISEMPTY);
19984
0
      goto isset_object_finish;
19985
0
    }
19986
0
  }
19987
19988
113
  if (IS_CV == IS_CONST) {
19989
0
    name = Z_STR_P(offset);
19990
113
  } else {
19991
113
    name = zval_try_get_tmp_string(offset, &tmp_name);
19992
113
    if (UNEXPECTED(!name)) {
19993
0
      result = 0;
19994
0
      goto isset_object_finish;
19995
0
    }
19996
113
  }
19997
19998
113
  result =
19999
113
    (opline->extended_value & ZEND_ISEMPTY) ^
20000
113
    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));
20001
20002
113
  if (IS_CV != IS_CONST) {
20003
113
    zend_tmp_string_release(tmp_name);
20004
113
  }
20005
20006
113
isset_object_finish:
20007
20008
113
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20009
113
  ZEND_VM_SMART_BRANCH(result, 1);
20010
113
}
20011
20012
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20013
0
{
20014
0
  USE_OPLINE
20015
20016
0
  zval *key, *subject;
20017
0
  HashTable *ht;
20018
0
  bool result;
20019
20020
0
  SAVE_OPLINE();
20021
20022
0
  key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
20023
0
  subject = EX_VAR(opline->op2.var);
20024
20025
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
20026
0
array_key_exists_array:
20027
0
    ht = Z_ARRVAL_P(subject);
20028
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
20029
0
  } else {
20030
0
    if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
20031
0
      subject = Z_REFVAL_P(subject);
20032
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
20033
0
        goto array_key_exists_array;
20034
0
      }
20035
0
    }
20036
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
20037
0
    result = 0;
20038
0
  }
20039
20040
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20041
0
  ZEND_VM_SMART_BRANCH(result, 1);
20042
0
}
20043
20044
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20045
6.80k
{
20046
6.80k
  USE_OPLINE
20047
6.80k
  zval *retval_ptr;
20048
6.80k
  zval *return_value;
20049
20050
6.80k
  retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20051
6.80k
  return_value = EX(return_value);
20052
20053
6.80k
  if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
20054
0
    SAVE_OPLINE();
20055
0
    retval_ptr = ZVAL_UNDEFINED_OP1();
20056
0
    if (return_value) {
20057
0
      ZVAL_NULL(return_value);
20058
0
    }
20059
6.80k
  } else if (!return_value) {
20060
195
    if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
20061
195
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
20062
66
        SAVE_OPLINE();
20063
66
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
20064
66
      }
20065
195
    }
20066
6.61k
  } else {
20067
6.61k
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20068
6.61k
      ZVAL_COPY_VALUE(return_value, retval_ptr);
20069
6.61k
      if (IS_TMP_VAR == IS_CONST) {
20070
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
20071
0
          Z_ADDREF_P(return_value);
20072
0
        }
20073
0
      }
20074
6.61k
    } else if (IS_TMP_VAR == IS_CV) {
20075
0
      do {
20076
0
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
20077
0
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
20078
0
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
20079
0
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
20080
0
              ZVAL_COPY_VALUE(return_value, retval_ptr);
20081
0
              if (GC_MAY_LEAK(ref)) {
20082
0
                SAVE_OPLINE();
20083
0
                gc_possible_root(ref);
20084
0
              }
20085
0
              ZVAL_NULL(retval_ptr);
20086
0
              break;
20087
0
            } else {
20088
0
              Z_ADDREF_P(retval_ptr);
20089
0
            }
20090
0
          } else {
20091
0
            retval_ptr = Z_REFVAL_P(retval_ptr);
20092
0
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
20093
0
              Z_ADDREF_P(retval_ptr);
20094
0
            }
20095
0
          }
20096
0
        }
20097
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
20098
0
      } while (0);
20099
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
20100
0
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
20101
0
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
20102
20103
0
        retval_ptr = Z_REFVAL_P(retval_ptr);
20104
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
20105
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20106
0
          efree_size(ref, sizeof(zend_reference));
20107
0
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
20108
0
          Z_ADDREF_P(retval_ptr);
20109
0
        }
20110
0
      } else {
20111
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
20112
0
      }
20113
0
    }
20114
6.61k
  }
20115
20116
20117
20118
6.80k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20119
6.80k
}
20120
20121
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20122
51
{
20123
51
  USE_OPLINE
20124
51
  zval *retval_ptr;
20125
51
  zval *return_value;
20126
20127
51
  SAVE_OPLINE();
20128
20129
51
  return_value = EX(return_value);
20130
20131
51
  do {
20132
51
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) ||
20133
51
        (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
20134
      /* Not supposed to happen, but we'll allow it */
20135
51
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
20136
20137
51
      retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20138
51
      if (!return_value) {
20139
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20140
51
      } else {
20141
51
        if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
20142
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
20143
0
          break;
20144
0
        }
20145
20146
51
        ZVAL_NEW_REF(return_value, retval_ptr);
20147
51
        if (IS_TMP_VAR == IS_CONST) {
20148
0
          Z_TRY_ADDREF_P(retval_ptr);
20149
0
        }
20150
51
      }
20151
51
      break;
20152
51
    }
20153
20154
0
    retval_ptr = zend_get_bad_ptr();
20155
20156
0
    if (IS_TMP_VAR == IS_VAR) {
20157
0
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
20158
0
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
20159
0
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
20160
0
        if (return_value) {
20161
0
          ZVAL_NEW_REF(return_value, retval_ptr);
20162
0
        } else {
20163
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20164
0
        }
20165
0
        break;
20166
0
      }
20167
0
    }
20168
20169
0
    if (return_value) {
20170
0
      if (Z_ISREF_P(retval_ptr)) {
20171
0
        Z_ADDREF_P(retval_ptr);
20172
0
      } else {
20173
0
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
20174
0
      }
20175
0
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
20176
0
    }
20177
20178
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20179
0
  } while (0);
20180
20181
20182
51
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20183
51
}
20184
20185
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20186
32
{
20187
32
  USE_OPLINE
20188
32
  zval *retval;
20189
20190
32
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20191
20192
32
  SAVE_OPLINE();
20193
32
  retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20194
20195
  /* Copy return value into generator->retval */
20196
32
  if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20197
32
    ZVAL_COPY_VALUE(&generator->retval, retval);
20198
32
    if (IS_TMP_VAR == IS_CONST) {
20199
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
20200
0
        Z_ADDREF(generator->retval);
20201
0
      }
20202
0
    }
20203
32
  } else if (IS_TMP_VAR == IS_CV) {
20204
0
    ZVAL_COPY_DEREF(&generator->retval, retval);
20205
0
  } else /* if (IS_TMP_VAR == IS_VAR) */ {
20206
0
    if (UNEXPECTED(Z_ISREF_P(retval))) {
20207
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
20208
20209
0
      retval = Z_REFVAL_P(retval);
20210
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
20211
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20212
0
        efree_size(ref, sizeof(zend_reference));
20213
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
20214
0
        Z_ADDREF_P(retval);
20215
0
      }
20216
0
    } else {
20217
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
20218
0
    }
20219
0
  }
20220
20221
32
  EG(current_execute_data) = EX(prev_execute_data);
20222
20223
  /* Close the generator to free up resources */
20224
32
  zend_generator_close(generator, 1);
20225
20226
  /* Pass execution back to handling code */
20227
32
  ZEND_VM_RETURN();
20228
32
}
20229
20230
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20231
13
{
20232
13
  USE_OPLINE
20233
13
  zval *arg, *param;
20234
20235
13
  SAVE_OPLINE();
20236
20237
13
  arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20238
13
  param = ZEND_CALL_VAR(EX(call), opline->result.var);
20239
13
  if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
20240
5
    zend_param_must_be_ref(EX(call)->func, opline->op2.num);
20241
5
    Z_TRY_ADDREF_P(arg);
20242
5
    ZVAL_NEW_REF(param, arg);
20243
8
  } else {
20244
8
    ZVAL_COPY(param, arg);
20245
8
  }
20246
20247
13
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20248
13
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20249
13
}
20250
20251
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20252
650
{
20253
650
  USE_OPLINE
20254
650
  zval *expr;
20255
650
  zval *result = EX_VAR(opline->result.var);
20256
20257
650
  SAVE_OPLINE();
20258
650
  expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20259
20260
650
  switch (opline->extended_value) {
20261
217
    case IS_LONG:
20262
217
      ZVAL_LONG(result, zval_get_long(expr));
20263
217
      break;
20264
36
    case IS_DOUBLE:
20265
36
      ZVAL_DOUBLE(result, zval_get_double(expr));
20266
36
      break;
20267
350
    case IS_STRING:
20268
350
      ZVAL_STR(result, zval_get_string(expr));
20269
350
      break;
20270
47
    default:
20271
47
      ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
20272
47
      if (IS_TMP_VAR & (IS_VAR|IS_CV)) {
20273
0
        ZVAL_DEREF(expr);
20274
0
      }
20275
      /* If value is already of correct type, return it directly */
20276
47
      if (Z_TYPE_P(expr) == opline->extended_value) {
20277
5
        ZVAL_COPY_VALUE(result, expr);
20278
5
        if (IS_TMP_VAR == IS_CONST) {
20279
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20280
5
        } else if (IS_TMP_VAR != IS_TMP_VAR) {
20281
0
          if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20282
0
        }
20283
20284
5
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20285
5
      }
20286
20287
42
      if (opline->extended_value == IS_ARRAY) {
20288
37
        zend_cast_zval_to_array(result, expr, IS_TMP_VAR);
20289
37
      } else {
20290
5
        ZEND_ASSERT(opline->extended_value == IS_OBJECT);
20291
5
        zend_cast_zval_to_object(result, expr, IS_TMP_VAR);
20292
5
      }
20293
650
  }
20294
20295
645
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20296
645
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20297
645
}
20298
20299
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20300
415
{
20301
415
  USE_OPLINE
20302
415
  zval *array_ptr, *result;
20303
20304
415
  SAVE_OPLINE();
20305
20306
415
  array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20307
415
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
20308
162
    result = EX_VAR(opline->result.var);
20309
162
    ZVAL_COPY_VALUE(result, array_ptr);
20310
162
    if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
20311
0
      Z_ADDREF_P(array_ptr);
20312
0
    }
20313
162
    Z_FE_POS_P(result) = 0;
20314
20315
162
    ZEND_VM_NEXT_OPCODE();
20316
253
  } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
20317
182
    zend_object *zobj = Z_OBJ_P(array_ptr);
20318
182
    if (!zobj->ce->get_iterator) {
20319
32
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
20320
0
        zobj = zend_lazy_object_init(zobj);
20321
0
        if (UNEXPECTED(EG(exception))) {
20322
0
          UNDEF_RESULT();
20323
20324
0
          HANDLE_EXCEPTION();
20325
0
        }
20326
0
      }
20327
32
      HashTable *properties = zobj->properties;
20328
32
      if (properties) {
20329
5
        if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
20330
0
          if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
20331
0
            GC_DELREF(properties);
20332
0
          }
20333
0
          properties = zobj->properties = zend_array_dup(properties);
20334
0
        }
20335
27
      } else {
20336
27
        properties = zobj->handlers->get_properties(zobj);
20337
27
      }
20338
20339
32
      result = EX_VAR(opline->result.var);
20340
32
      ZVAL_COPY_VALUE(result, array_ptr);
20341
32
      if (IS_TMP_VAR != IS_TMP_VAR) {
20342
0
        Z_ADDREF_P(array_ptr);
20343
0
      }
20344
20345
32
      if (zend_hash_num_elements(properties) == 0) {
20346
10
        Z_FE_ITER_P(result) = (uint32_t) -1;
20347
20348
10
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20349
10
      }
20350
20351
22
      Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
20352
20353
22
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20354
150
    } else {
20355
150
      bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
20356
20357
150
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20358
150
      if (UNEXPECTED(EG(exception))) {
20359
53
        HANDLE_EXCEPTION();
20360
97
      } else if (is_empty) {
20361
25
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20362
72
      } else {
20363
72
        ZEND_VM_NEXT_OPCODE();
20364
72
      }
20365
150
    }
20366
182
  } else {
20367
71
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
20368
71
    ZVAL_UNDEF(EX_VAR(opline->result.var));
20369
71
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
20370
71
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20371
71
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20372
71
  }
20373
415
}
20374
20375
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20376
32
{
20377
32
  USE_OPLINE
20378
32
  zval *array_ptr, *array_ref;
20379
20380
32
  SAVE_OPLINE();
20381
20382
32
  if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20383
0
    array_ref = array_ptr = zend_get_bad_ptr();
20384
0
    if (Z_ISREF_P(array_ref)) {
20385
0
      array_ptr = Z_REFVAL_P(array_ref);
20386
0
    }
20387
32
  } else {
20388
32
    array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20389
32
  }
20390
20391
32
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
20392
22
    if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20393
0
      if (array_ptr == array_ref) {
20394
0
        ZVAL_NEW_REF(array_ref, array_ref);
20395
0
        array_ptr = Z_REFVAL_P(array_ref);
20396
0
      }
20397
0
      Z_ADDREF_P(array_ref);
20398
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
20399
22
    } else {
20400
22
      array_ref = EX_VAR(opline->result.var);
20401
22
      ZVAL_NEW_REF(array_ref, array_ptr);
20402
22
      array_ptr = Z_REFVAL_P(array_ref);
20403
22
    }
20404
22
    if (IS_TMP_VAR == IS_CONST) {
20405
0
      ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
20406
22
    } else {
20407
22
      SEPARATE_ARRAY(array_ptr);
20408
22
    }
20409
22
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
20410
20411
22
    ZEND_VM_NEXT_OPCODE();
20412
22
  } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
20413
0
    if (!Z_OBJCE_P(array_ptr)->get_iterator) {
20414
0
      zend_object *zobj = Z_OBJ_P(array_ptr);
20415
0
      HashTable *properties;
20416
0
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
20417
0
        zobj = zend_lazy_object_init(zobj);
20418
0
        if (UNEXPECTED(EG(exception))) {
20419
0
          UNDEF_RESULT();
20420
20421
0
          HANDLE_EXCEPTION();
20422
0
        }
20423
0
      }
20424
0
      if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20425
0
        if (array_ptr == array_ref) {
20426
0
          ZVAL_NEW_REF(array_ref, array_ref);
20427
0
          array_ptr = Z_REFVAL_P(array_ref);
20428
0
        }
20429
0
        Z_ADDREF_P(array_ref);
20430
0
        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
20431
0
      } else {
20432
0
        array_ptr = EX_VAR(opline->result.var);
20433
0
        ZVAL_COPY_VALUE(array_ptr, array_ref);
20434
0
      }
20435
0
      if (Z_OBJ_P(array_ptr)->properties
20436
0
       && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
20437
0
        if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
20438
0
          GC_DELREF(Z_OBJ_P(array_ptr)->properties);
20439
0
        }
20440
0
        Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
20441
0
      }
20442
20443
0
      properties = Z_OBJPROP_P(array_ptr);
20444
0
      if (zend_hash_num_elements(properties) == 0) {
20445
0
        Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
20446
20447
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20448
0
      }
20449
20450
0
      Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
20451
20452
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20453
0
    } else {
20454
0
      bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
20455
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20456
0
      if (UNEXPECTED(EG(exception))) {
20457
0
        HANDLE_EXCEPTION();
20458
0
      } else if (is_empty) {
20459
0
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20460
0
      } else {
20461
0
        ZEND_VM_NEXT_OPCODE();
20462
0
      }
20463
0
    }
20464
10
  } else {
20465
10
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
20466
10
    ZVAL_UNDEF(EX_VAR(opline->result.var));
20467
10
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
20468
10
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20469
10
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20470
10
  }
20471
32
}
20472
20473
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20474
22.1k
{
20475
22.1k
  USE_OPLINE
20476
20477
22.1k
  if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))
20478
22.1k
      && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) {
20479
134
    EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
20480
134
  }
20481
22.1k
  ZEND_VM_NEXT_OPCODE();
20482
22.1k
}
20483
20484
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20485
1.52k
{
20486
1.52k
  USE_OPLINE
20487
1.52k
  zval *value;
20488
1.52k
  zend_reference *ref = NULL;
20489
1.52k
  bool ret;
20490
20491
1.52k
  SAVE_OPLINE();
20492
1.52k
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20493
20494
1.52k
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) {
20495
0
    if (IS_TMP_VAR == IS_VAR) {
20496
0
      ref = Z_REF_P(value);
20497
0
    }
20498
0
    value = Z_REFVAL_P(value);
20499
0
  }
20500
20501
1.52k
  ret = i_zend_is_true(value);
20502
20503
1.52k
  if (UNEXPECTED(EG(exception))) {
20504
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20505
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
20506
0
    HANDLE_EXCEPTION();
20507
0
  }
20508
20509
1.52k
  if (ret) {
20510
863
    zval *result = EX_VAR(opline->result.var);
20511
20512
863
    ZVAL_COPY_VALUE(result, value);
20513
863
    if (IS_TMP_VAR == IS_CONST) {
20514
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20515
863
    } else if (IS_TMP_VAR == IS_CV) {
20516
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20517
863
    } else if (IS_TMP_VAR == IS_VAR && ref) {
20518
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20519
0
        efree_size(ref, sizeof(zend_reference));
20520
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
20521
0
        Z_ADDREF_P(result);
20522
0
      }
20523
0
    }
20524
863
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20525
863
  }
20526
20527
659
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20528
659
  ZEND_VM_NEXT_OPCODE();
20529
659
}
20530
20531
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20532
1.57k
{
20533
1.57k
  USE_OPLINE
20534
1.57k
  zval *value;
20535
1.57k
  zend_reference *ref = NULL;
20536
20537
1.57k
  SAVE_OPLINE();
20538
1.57k
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20539
20540
1.57k
  if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20541
0
    if (IS_TMP_VAR & IS_VAR) {
20542
0
      ref = Z_REF_P(value);
20543
0
    }
20544
0
    value = Z_REFVAL_P(value);
20545
0
  }
20546
20547
1.57k
  if (Z_TYPE_P(value) > IS_NULL) {
20548
698
    zval *result = EX_VAR(opline->result.var);
20549
698
    ZVAL_COPY_VALUE(result, value);
20550
698
    if (IS_TMP_VAR == IS_CONST) {
20551
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20552
698
    } else if (IS_TMP_VAR == IS_CV) {
20553
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20554
698
    } else if ((IS_TMP_VAR & IS_VAR) && ref) {
20555
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20556
0
        efree_size(ref, sizeof(zend_reference));
20557
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
20558
0
        Z_ADDREF_P(result);
20559
0
      }
20560
0
    }
20561
698
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20562
698
  }
20563
20564
872
  if ((IS_TMP_VAR & IS_VAR) && ref) {
20565
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20566
0
      efree_size(ref, sizeof(zend_reference));
20567
0
    }
20568
0
  }
20569
872
  ZEND_VM_NEXT_OPCODE();
20570
872
}
20571
20572
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20573
216
{
20574
216
  USE_OPLINE
20575
216
  zval *val, *result;
20576
20577
216
  val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20578
20579
216
  if (Z_TYPE_P(val) > IS_NULL) {
20580
27
    do {
20581
27
      if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
20582
0
        val = Z_REFVAL_P(val);
20583
0
        if (Z_TYPE_P(val) <= IS_NULL) {
20584
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20585
0
          break;
20586
0
        }
20587
0
      }
20588
27
      ZEND_VM_NEXT_OPCODE();
20589
27
    } while (0);
20590
27
  }
20591
20592
189
  result = EX_VAR(opline->result.var);
20593
189
  uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
20594
189
  if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
20595
189
    ZVAL_NULL(result);
20596
189
    if (IS_TMP_VAR == IS_CV
20597
189
      && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
20598
189
      && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
20599
189
    ) {
20600
0
      SAVE_OPLINE();
20601
0
      ZVAL_UNDEFINED_OP1();
20602
0
      if (UNEXPECTED(EG(exception) != NULL)) {
20603
0
        HANDLE_EXCEPTION();
20604
0
      }
20605
0
    }
20606
189
  } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
20607
0
    ZVAL_FALSE(result);
20608
0
  } else {
20609
0
    ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
20610
0
    ZVAL_TRUE(result);
20611
0
  }
20612
20613
189
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20614
189
}
20615
20616
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20617
403
{
20618
403
  USE_OPLINE
20619
403
  zval *value;
20620
403
  zval *result = EX_VAR(opline->result.var);
20621
20622
403
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20623
403
  if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
20624
0
    SAVE_OPLINE();
20625
0
    ZVAL_UNDEFINED_OP1();
20626
0
    ZVAL_NULL(result);
20627
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20628
0
  }
20629
20630
403
  if (IS_TMP_VAR == IS_CV) {
20631
0
    ZVAL_COPY_DEREF(result, value);
20632
403
  } else if (IS_TMP_VAR == IS_VAR) {
20633
0
    if (UNEXPECTED(Z_ISREF_P(value))) {
20634
0
      ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
20635
0
      if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
20636
0
        efree_size(Z_REF_P(value), sizeof(zend_reference));
20637
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
20638
0
        Z_ADDREF_P(result);
20639
0
      }
20640
0
    } else {
20641
0
      ZVAL_COPY_VALUE(result, value);
20642
0
    }
20643
403
  } else {
20644
403
    ZVAL_COPY_VALUE(result, value);
20645
403
    if (IS_TMP_VAR == IS_CONST) {
20646
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
20647
0
        Z_ADDREF_P(result);
20648
0
      }
20649
0
    }
20650
403
  }
20651
403
  ZEND_VM_NEXT_OPCODE();
20652
403
}
20653
20654
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20655
1.12k
{
20656
1.12k
  USE_OPLINE
20657
1.12k
  zval *op1, *op2;
20658
1.12k
  bool result;
20659
20660
1.12k
  SAVE_OPLINE();
20661
1.12k
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20662
1.12k
  op2 = RT_CONSTANT(opline, opline->op2);
20663
1.12k
  result = fast_is_identical_function(op1, op2);
20664
1.12k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20665
20666
1.12k
  ZEND_VM_SMART_BRANCH(result, 1);
20667
1.12k
}
20668
20669
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20670
0
{
20671
0
  USE_OPLINE
20672
0
  zval *op1, *op2;
20673
0
  bool result;
20674
20675
0
  SAVE_OPLINE();
20676
0
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20677
0
  op2 = RT_CONSTANT(opline, opline->op2);
20678
0
  result = fast_is_identical_function(op1, op2);
20679
20680
0
  ZEND_VM_SMART_BRANCH(result, 1);
20681
0
}
20682
20683
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20684
143
{
20685
143
  USE_OPLINE
20686
143
  zval *op1, *op2;
20687
143
  bool result;
20688
20689
143
  SAVE_OPLINE();
20690
143
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20691
143
  op2 = RT_CONSTANT(opline, opline->op2);
20692
143
  result = fast_is_not_identical_function(op1, op2);
20693
143
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20694
20695
143
  ZEND_VM_SMART_BRANCH(result, 1);
20696
143
}
20697
20698
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20699
10
{
20700
#if 0
20701
  USE_OPLINE
20702
#endif
20703
20704
10
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20705
10
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20706
10
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20707
10
    }
20708
10
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20709
10
  } else {
20710
0
    if (IS_CONST == IS_UNUSED) {
20711
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20712
0
    }
20713
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20714
0
  }
20715
10
}
20716
20717
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20718
0
{
20719
#if 0
20720
  USE_OPLINE
20721
#endif
20722
20723
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20724
    /* Behave like FETCH_OBJ_W */
20725
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20726
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20727
0
    }
20728
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20729
0
  } else {
20730
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20731
0
  }
20732
0
}
20733
20734
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20735
442k
{
20736
442k
  USE_OPLINE
20737
442k
  zend_string **rope;
20738
442k
  zval *var;
20739
20740
  /* op1 and result are the same */
20741
442k
  rope = (zend_string**)EX_VAR(opline->op1.var);
20742
442k
  if (IS_CONST == IS_CONST) {
20743
442k
    var = RT_CONSTANT(opline, opline->op2);
20744
442k
    rope[opline->extended_value] = Z_STR_P(var);
20745
442k
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20746
3
      Z_ADDREF_P(var);
20747
3
    }
20748
442k
  } else {
20749
0
    var = RT_CONSTANT(opline, opline->op2);
20750
0
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20751
0
      if (IS_CONST == IS_CV) {
20752
0
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20753
0
      } else {
20754
0
        rope[opline->extended_value] = Z_STR_P(var);
20755
0
      }
20756
0
    } else {
20757
0
      SAVE_OPLINE();
20758
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20759
0
        ZVAL_UNDEFINED_OP2();
20760
0
      }
20761
0
      rope[opline->extended_value] = zval_get_string_func(var);
20762
20763
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20764
0
    }
20765
0
  }
20766
442k
  ZEND_VM_NEXT_OPCODE();
20767
442k
}
20768
20769
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20770
287k
{
20771
287k
  USE_OPLINE
20772
287k
  zend_string **rope;
20773
287k
  zval *var, *ret;
20774
287k
  uint32_t i;
20775
20776
287k
  rope = (zend_string**)EX_VAR(opline->op1.var);
20777
287k
  if (IS_CONST == IS_CONST) {
20778
287k
    var = RT_CONSTANT(opline, opline->op2);
20779
287k
    rope[opline->extended_value] = Z_STR_P(var);
20780
287k
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20781
3
      Z_ADDREF_P(var);
20782
3
    }
20783
287k
  } else {
20784
0
    var = RT_CONSTANT(opline, opline->op2);
20785
0
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20786
0
      if (IS_CONST == IS_CV) {
20787
0
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20788
0
      } else {
20789
0
        rope[opline->extended_value] = Z_STR_P(var);
20790
0
      }
20791
0
    } else {
20792
0
      SAVE_OPLINE();
20793
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20794
0
        ZVAL_UNDEFINED_OP2();
20795
0
      }
20796
0
      rope[opline->extended_value] = zval_get_string_func(var);
20797
20798
0
      if (UNEXPECTED(EG(exception))) {
20799
0
        for (i = 0; i <= opline->extended_value; i++) {
20800
0
          zend_string_release_ex(rope[i], 0);
20801
0
        }
20802
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
20803
0
        HANDLE_EXCEPTION();
20804
0
      }
20805
0
    }
20806
0
  }
20807
20808
287k
  size_t len = 0;
20809
287k
  uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
20810
1.91M
  for (i = 0; i <= opline->extended_value; i++) {
20811
1.63M
    flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
20812
1.63M
    len += ZSTR_LEN(rope[i]);
20813
1.63M
  }
20814
287k
  ret = EX_VAR(opline->result.var);
20815
287k
  ZVAL_STR(ret, zend_string_alloc(len, 0));
20816
287k
  GC_ADD_FLAGS(Z_STR_P(ret), flags);
20817
20818
287k
  char *target = Z_STRVAL_P(ret);
20819
1.91M
  for (i = 0; i <= opline->extended_value; i++) {
20820
1.63M
    memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
20821
1.63M
    target += ZSTR_LEN(rope[i]);
20822
1.63M
    zend_string_release_ex(rope[i], 0);
20823
1.63M
  }
20824
287k
  *target = '\0';
20825
20826
287k
  ZEND_VM_NEXT_OPCODE();
20827
287k
}
20828
20829
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20830
9
{
20831
9
  USE_OPLINE
20832
9
  zval *value, *arg;
20833
9
  uint32_t arg_num;
20834
20835
9
  if (IS_CONST == IS_CONST) {
20836
9
    SAVE_OPLINE();
20837
9
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
20838
9
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
20839
9
    if (UNEXPECTED(!arg)) {
20840
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20841
0
      HANDLE_EXCEPTION();
20842
0
    }
20843
9
  } else {
20844
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
20845
0
    arg_num = opline->op2.num;
20846
0
  }
20847
20848
9
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
20849
9
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20850
2
      goto send_val_by_ref;
20851
2
    }
20852
9
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20853
2
send_val_by_ref:
20854
2
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
20855
0
  }
20856
7
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20857
7
  ZVAL_COPY_VALUE(arg, value);
20858
7
  if (IS_TMP_VAR == IS_CONST) {
20859
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
20860
0
      Z_ADDREF_P(arg);
20861
0
    }
20862
0
  }
20863
7
  ZEND_VM_NEXT_OPCODE();
20864
7
}
20865
20866
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20867
305
{
20868
305
  USE_OPLINE
20869
305
  zval *expr_ptr, new_expr;
20870
20871
305
  SAVE_OPLINE();
20872
305
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
20873
305
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
20874
0
    expr_ptr = zend_get_bad_ptr();
20875
0
    if (Z_ISREF_P(expr_ptr)) {
20876
0
      Z_ADDREF_P(expr_ptr);
20877
0
    } else {
20878
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
20879
0
    }
20880
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20881
305
  } else {
20882
305
    expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20883
305
    if (IS_TMP_VAR == IS_TMP_VAR) {
20884
      /* pass */
20885
305
    } else if (IS_TMP_VAR == IS_CONST) {
20886
0
      Z_TRY_ADDREF_P(expr_ptr);
20887
0
    } else if (IS_TMP_VAR == IS_CV) {
20888
0
      ZVAL_DEREF(expr_ptr);
20889
0
      Z_TRY_ADDREF_P(expr_ptr);
20890
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
20891
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
20892
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
20893
20894
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
20895
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20896
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
20897
0
          expr_ptr = &new_expr;
20898
0
          efree_size(ref, sizeof(zend_reference));
20899
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
20900
0
          Z_ADDREF_P(expr_ptr);
20901
0
        }
20902
0
      }
20903
0
    }
20904
305
  }
20905
20906
305
  if (IS_CONST != IS_UNUSED) {
20907
305
    zval *offset = RT_CONSTANT(opline, opline->op2);
20908
305
    zend_string *str;
20909
305
    zend_ulong hval;
20910
20911
305
add_again:
20912
305
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
20913
289
      str = Z_STR_P(offset);
20914
289
      if (IS_CONST != IS_CONST) {
20915
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
20916
0
          goto num_index;
20917
0
        }
20918
0
      }
20919
289
str_index:
20920
289
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
20921
289
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
20922
15
      hval = Z_LVAL_P(offset);
20923
16
num_index:
20924
16
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
20925
16
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
20926
0
      offset = Z_REFVAL_P(offset);
20927
0
      goto add_again;
20928
1
    } else if (Z_TYPE_P(offset) == IS_NULL) {
20929
0
      str = ZSTR_EMPTY_ALLOC();
20930
0
      goto str_index;
20931
1
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
20932
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
20933
0
      goto num_index;
20934
1
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
20935
1
      hval = 0;
20936
1
      goto num_index;
20937
1
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
20938
0
      hval = 1;
20939
0
      goto num_index;
20940
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
20941
0
      zend_use_resource_as_offset(offset);
20942
0
      hval = Z_RES_HANDLE_P(offset);
20943
0
      goto num_index;
20944
0
    } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
20945
0
      ZVAL_UNDEFINED_OP2();
20946
0
      str = ZSTR_EMPTY_ALLOC();
20947
0
      goto str_index;
20948
0
    } else {
20949
0
      zend_illegal_array_offset_access(offset);
20950
0
      zval_ptr_dtor_nogc(expr_ptr);
20951
0
    }
20952
20953
305
  } else {
20954
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
20955
0
      zend_cannot_add_element();
20956
0
      zval_ptr_dtor_nogc(expr_ptr);
20957
0
    }
20958
0
  }
20959
305
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20960
305
}
20961
20962
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20963
69
{
20964
69
  zval *array;
20965
69
  uint32_t size;
20966
69
  USE_OPLINE
20967
20968
69
  SAVE_OPLINE();
20969
69
  array = EX_VAR(opline->result.var);
20970
69
  if (IS_TMP_VAR != IS_UNUSED) {
20971
69
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
20972
69
    ZVAL_ARR(array, zend_new_array(size));
20973
    /* Explicitly initialize array as not-packed if flag is set */
20974
69
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
20975
59
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
20976
59
    }
20977
69
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20978
69
  } else {
20979
0
    ZVAL_ARR(array, zend_new_array(0));
20980
0
    ZEND_VM_NEXT_OPCODE();
20981
0
  }
20982
69
}
20983
20984
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20985
0
{
20986
0
  USE_OPLINE
20987
20988
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20989
20990
0
  SAVE_OPLINE();
20991
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
20992
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20993
0
  }
20994
20995
  /* Destroy the previously yielded value */
20996
0
  zval_ptr_dtor(&generator->value);
20997
20998
  /* Destroy the previously yielded key */
20999
0
  zval_ptr_dtor(&generator->key);
21000
21001
  /* Set the new yielded value */
21002
0
  if (IS_TMP_VAR != IS_UNUSED) {
21003
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21004
      /* Constants and temporary variables aren't yieldable by reference,
21005
       * but we still allow them with a notice. */
21006
0
      if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21007
0
        zval *value;
21008
21009
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21010
21011
0
        value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21012
0
        ZVAL_COPY_VALUE(&generator->value, value);
21013
0
        if (IS_TMP_VAR == IS_CONST) {
21014
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21015
0
            Z_ADDREF(generator->value);
21016
0
          }
21017
0
        }
21018
0
      } else {
21019
0
        zval *value_ptr = zend_get_bad_ptr();
21020
21021
        /* If a function call result is yielded and the function did
21022
         * not return by reference we throw a notice. */
21023
0
        do {
21024
0
          if (IS_TMP_VAR == IS_VAR) {
21025
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21026
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
21027
0
             && !Z_ISREF_P(value_ptr)) {
21028
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21029
0
              ZVAL_COPY(&generator->value, value_ptr);
21030
0
              break;
21031
0
            }
21032
0
          }
21033
0
          if (Z_ISREF_P(value_ptr)) {
21034
0
            Z_ADDREF_P(value_ptr);
21035
0
          } else {
21036
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
21037
0
          }
21038
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21039
0
        } while (0);
21040
21041
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21042
0
      }
21043
0
    } else {
21044
0
      zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21045
21046
      /* Consts, temporary variables and references need copying */
21047
0
      if (IS_TMP_VAR == IS_CONST) {
21048
0
        ZVAL_COPY_VALUE(&generator->value, value);
21049
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21050
0
          Z_ADDREF(generator->value);
21051
0
        }
21052
0
      } else if (IS_TMP_VAR == IS_TMP_VAR) {
21053
0
        ZVAL_COPY_VALUE(&generator->value, value);
21054
0
      } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21055
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21056
21057
0
      } else {
21058
0
        ZVAL_COPY_VALUE(&generator->value, value);
21059
0
        if (IS_TMP_VAR == IS_CV) {
21060
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21061
0
        }
21062
0
      }
21063
0
    }
21064
0
  } else {
21065
    /* If no value was specified yield null */
21066
0
    ZVAL_NULL(&generator->value);
21067
0
  }
21068
21069
  /* Set the new yielded key */
21070
0
  if (IS_CONST != IS_UNUSED) {
21071
0
    zval *key = RT_CONSTANT(opline, opline->op2);
21072
0
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21073
0
      key = Z_REFVAL_P(key);
21074
0
    }
21075
0
    ZVAL_COPY(&generator->key, key);
21076
21077
0
    if (Z_TYPE(generator->key) == IS_LONG
21078
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
21079
0
    ) {
21080
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
21081
0
    }
21082
0
  } else {
21083
    /* If no key was specified we use auto-increment keys */
21084
0
    generator->largest_used_integer_key++;
21085
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21086
0
  }
21087
21088
0
  if (RETURN_VALUE_USED(opline)) {
21089
    /* If the return value of yield is used set the send
21090
     * target and initialize it to NULL */
21091
0
    generator->send_target = EX_VAR(opline->result.var);
21092
0
    ZVAL_NULL(generator->send_target);
21093
0
  } else {
21094
0
    generator->send_target = NULL;
21095
0
  }
21096
21097
  /* The GOTO VM uses a local opline variable. We need to set the opline
21098
   * variable in execute_data so we don't resume at an old position. */
21099
0
  SAVE_OPLINE();
21100
21101
0
  ZEND_VM_RETURN();
21102
0
}
21103
21104
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21105
0
{
21106
0
  USE_OPLINE
21107
0
  zval *op1;
21108
0
  HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
21109
0
  zval *result;
21110
21111
0
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21112
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
21113
0
    result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST);
21114
0
    if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) {
21115
0
      zval_ptr_dtor_str(op1);
21116
0
    }
21117
0
    ZEND_VM_SMART_BRANCH(result, 0);
21118
0
  }
21119
21120
0
  if (opline->extended_value) {
21121
0
    if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
21122
0
      result = zend_hash_index_find(ht, Z_LVAL_P(op1));
21123
0
      ZEND_VM_SMART_BRANCH(result, 0);
21124
0
    }
21125
0
    SAVE_OPLINE();
21126
0
    if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
21127
0
      op1 = Z_REFVAL_P(op1);
21128
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
21129
0
        result = zend_hash_find(ht, Z_STR_P(op1));
21130
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21131
0
        ZEND_VM_SMART_BRANCH(result, 0);
21132
0
      } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
21133
0
        result = zend_hash_index_find(ht, Z_LVAL_P(op1));
21134
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21135
0
        ZEND_VM_SMART_BRANCH(result, 0);
21136
0
      }
21137
0
    } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
21138
0
      ZVAL_UNDEFINED_OP1();
21139
0
    }
21140
0
  } else if (Z_TYPE_P(op1) <= IS_FALSE) {
21141
0
    if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
21142
0
      SAVE_OPLINE();
21143
0
      ZVAL_UNDEFINED_OP1();
21144
0
      if (UNEXPECTED(EG(exception) != NULL)) {
21145
0
        HANDLE_EXCEPTION();
21146
0
      }
21147
0
    }
21148
0
    result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
21149
0
    ZEND_VM_SMART_BRANCH(result, 0);
21150
0
  } else {
21151
0
    zend_string *key;
21152
0
    zval key_tmp;
21153
21154
0
    if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
21155
0
      op1 = Z_REFVAL_P(op1);
21156
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
21157
0
        result = zend_hash_find(ht, Z_STR_P(op1));
21158
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21159
0
        ZEND_VM_SMART_BRANCH(result, 0);
21160
0
      }
21161
0
    }
21162
21163
0
    SAVE_OPLINE();
21164
0
    ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
21165
0
      ZVAL_STR(&key_tmp, key);
21166
0
      if (zend_compare(op1, &key_tmp) == 0) {
21167
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21168
0
        ZEND_VM_SMART_BRANCH(1, 1);
21169
0
      }
21170
0
    } ZEND_HASH_FOREACH_END();
21171
0
  }
21172
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21173
0
  ZEND_VM_SMART_BRANCH(0, 1);
21174
0
}
21175
21176
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21177
0
{
21178
#if 0
21179
  USE_OPLINE
21180
#endif
21181
21182
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21183
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21184
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21185
0
    }
21186
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21187
0
  } else {
21188
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
21189
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21190
0
    }
21191
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21192
0
  }
21193
0
}
21194
21195
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21196
0
{
21197
#if 0
21198
  USE_OPLINE
21199
#endif
21200
21201
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21202
    /* Behave like FETCH_OBJ_W */
21203
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21204
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21205
0
    }
21206
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21207
0
  } else {
21208
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21209
0
  }
21210
0
}
21211
21212
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21213
89.3k
{
21214
89.3k
  USE_OPLINE
21215
89.3k
  zend_string **rope;
21216
89.3k
  zval *var;
21217
21218
  /* op1 and result are the same */
21219
89.3k
  rope = (zend_string**)EX_VAR(opline->op1.var);
21220
89.3k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
21221
0
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21222
0
    rope[opline->extended_value] = Z_STR_P(var);
21223
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21224
0
      Z_ADDREF_P(var);
21225
0
    }
21226
89.3k
  } else {
21227
89.3k
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21228
89.3k
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21229
380
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
21230
0
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21231
380
      } else {
21232
380
        rope[opline->extended_value] = Z_STR_P(var);
21233
380
      }
21234
88.9k
    } else {
21235
88.9k
      SAVE_OPLINE();
21236
88.9k
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21237
0
        ZVAL_UNDEFINED_OP2();
21238
0
      }
21239
88.9k
      rope[opline->extended_value] = zval_get_string_func(var);
21240
88.9k
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21241
88.9k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21242
88.9k
    }
21243
89.3k
  }
21244
380
  ZEND_VM_NEXT_OPCODE();
21245
380
}
21246
21247
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21248
525
{
21249
525
  USE_OPLINE
21250
525
  zend_string **rope;
21251
525
  zval *var, *ret;
21252
525
  uint32_t i;
21253
21254
525
  rope = (zend_string**)EX_VAR(opline->op1.var);
21255
525
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
21256
0
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21257
0
    rope[opline->extended_value] = Z_STR_P(var);
21258
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21259
0
      Z_ADDREF_P(var);
21260
0
    }
21261
525
  } else {
21262
525
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21263
525
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21264
10
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
21265
0
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21266
10
      } else {
21267
10
        rope[opline->extended_value] = Z_STR_P(var);
21268
10
      }
21269
515
    } else {
21270
515
      SAVE_OPLINE();
21271
515
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21272
0
        ZVAL_UNDEFINED_OP2();
21273
0
      }
21274
515
      rope[opline->extended_value] = zval_get_string_func(var);
21275
515
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21276
515
      if (UNEXPECTED(EG(exception))) {
21277
0
        for (i = 0; i <= opline->extended_value; i++) {
21278
0
          zend_string_release_ex(rope[i], 0);
21279
0
        }
21280
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
21281
0
        HANDLE_EXCEPTION();
21282
0
      }
21283
515
    }
21284
525
  }
21285
21286
525
  size_t len = 0;
21287
525
  uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
21288
21.6k
  for (i = 0; i <= opline->extended_value; i++) {
21289
21.0k
    flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
21290
21.0k
    len += ZSTR_LEN(rope[i]);
21291
21.0k
  }
21292
525
  ret = EX_VAR(opline->result.var);
21293
525
  ZVAL_STR(ret, zend_string_alloc(len, 0));
21294
525
  GC_ADD_FLAGS(Z_STR_P(ret), flags);
21295
21296
525
  char *target = Z_STRVAL_P(ret);
21297
21.6k
  for (i = 0; i <= opline->extended_value; i++) {
21298
21.0k
    memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
21299
21.0k
    target += ZSTR_LEN(rope[i]);
21300
21.0k
    zend_string_release_ex(rope[i], 0);
21301
21.0k
  }
21302
525
  *target = '\0';
21303
21304
525
  ZEND_VM_NEXT_OPCODE();
21305
525
}
21306
21307
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21308
3
{
21309
3
  USE_OPLINE
21310
3
  zval *expr_ptr, new_expr;
21311
21312
3
  SAVE_OPLINE();
21313
3
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21314
3
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21315
0
    expr_ptr = zend_get_bad_ptr();
21316
0
    if (Z_ISREF_P(expr_ptr)) {
21317
0
      Z_ADDREF_P(expr_ptr);
21318
0
    } else {
21319
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
21320
0
    }
21321
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21322
3
  } else {
21323
3
    expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21324
3
    if (IS_TMP_VAR == IS_TMP_VAR) {
21325
      /* pass */
21326
3
    } else if (IS_TMP_VAR == IS_CONST) {
21327
0
      Z_TRY_ADDREF_P(expr_ptr);
21328
0
    } else if (IS_TMP_VAR == IS_CV) {
21329
0
      ZVAL_DEREF(expr_ptr);
21330
0
      Z_TRY_ADDREF_P(expr_ptr);
21331
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
21332
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21333
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21334
21335
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
21336
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21337
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21338
0
          expr_ptr = &new_expr;
21339
0
          efree_size(ref, sizeof(zend_reference));
21340
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21341
0
          Z_ADDREF_P(expr_ptr);
21342
0
        }
21343
0
      }
21344
0
    }
21345
3
  }
21346
21347
3
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
21348
3
    zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21349
3
    zend_string *str;
21350
3
    zend_ulong hval;
21351
21352
3
add_again:
21353
3
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21354
3
      str = Z_STR_P(offset);
21355
3
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
21356
3
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
21357
0
          goto num_index;
21358
0
        }
21359
3
      }
21360
3
str_index:
21361
3
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21362
3
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21363
0
      hval = Z_LVAL_P(offset);
21364
0
num_index:
21365
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21366
0
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21367
0
      offset = Z_REFVAL_P(offset);
21368
0
      goto add_again;
21369
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
21370
0
      str = ZSTR_EMPTY_ALLOC();
21371
0
      goto str_index;
21372
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21373
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21374
0
      goto num_index;
21375
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
21376
0
      hval = 0;
21377
0
      goto num_index;
21378
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
21379
0
      hval = 1;
21380
0
      goto num_index;
21381
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21382
0
      zend_use_resource_as_offset(offset);
21383
0
      hval = Z_RES_HANDLE_P(offset);
21384
0
      goto num_index;
21385
0
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21386
0
      ZVAL_UNDEFINED_OP2();
21387
0
      str = ZSTR_EMPTY_ALLOC();
21388
0
      goto str_index;
21389
0
    } else {
21390
0
      zend_illegal_array_offset_access(offset);
21391
0
      zval_ptr_dtor_nogc(expr_ptr);
21392
0
    }
21393
3
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21394
3
  } else {
21395
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21396
0
      zend_cannot_add_element();
21397
0
      zval_ptr_dtor_nogc(expr_ptr);
21398
0
    }
21399
0
  }
21400
3
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21401
3
}
21402
21403
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21404
0
{
21405
0
  zval *array;
21406
0
  uint32_t size;
21407
0
  USE_OPLINE
21408
21409
0
  SAVE_OPLINE();
21410
0
  array = EX_VAR(opline->result.var);
21411
0
  if (IS_TMP_VAR != IS_UNUSED) {
21412
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21413
0
    ZVAL_ARR(array, zend_new_array(size));
21414
    /* Explicitly initialize array as not-packed if flag is set */
21415
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21416
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21417
0
    }
21418
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21419
0
  } else {
21420
0
    ZVAL_ARR(array, zend_new_array(0));
21421
0
    ZEND_VM_NEXT_OPCODE();
21422
0
  }
21423
0
}
21424
21425
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21426
5
{
21427
5
  USE_OPLINE
21428
21429
5
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21430
21431
5
  SAVE_OPLINE();
21432
5
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21433
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21434
0
  }
21435
21436
  /* Destroy the previously yielded value */
21437
5
  zval_ptr_dtor(&generator->value);
21438
21439
  /* Destroy the previously yielded key */
21440
5
  zval_ptr_dtor(&generator->key);
21441
21442
  /* Set the new yielded value */
21443
5
  if (IS_TMP_VAR != IS_UNUSED) {
21444
5
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21445
      /* Constants and temporary variables aren't yieldable by reference,
21446
       * but we still allow them with a notice. */
21447
0
      if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21448
0
        zval *value;
21449
21450
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21451
21452
0
        value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21453
0
        ZVAL_COPY_VALUE(&generator->value, value);
21454
0
        if (IS_TMP_VAR == IS_CONST) {
21455
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21456
0
            Z_ADDREF(generator->value);
21457
0
          }
21458
0
        }
21459
0
      } else {
21460
0
        zval *value_ptr = zend_get_bad_ptr();
21461
21462
        /* If a function call result is yielded and the function did
21463
         * not return by reference we throw a notice. */
21464
0
        do {
21465
0
          if (IS_TMP_VAR == IS_VAR) {
21466
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21467
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
21468
0
             && !Z_ISREF_P(value_ptr)) {
21469
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21470
0
              ZVAL_COPY(&generator->value, value_ptr);
21471
0
              break;
21472
0
            }
21473
0
          }
21474
0
          if (Z_ISREF_P(value_ptr)) {
21475
0
            Z_ADDREF_P(value_ptr);
21476
0
          } else {
21477
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
21478
0
          }
21479
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21480
0
        } while (0);
21481
21482
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21483
0
      }
21484
5
    } else {
21485
5
      zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21486
21487
      /* Consts, temporary variables and references need copying */
21488
5
      if (IS_TMP_VAR == IS_CONST) {
21489
0
        ZVAL_COPY_VALUE(&generator->value, value);
21490
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21491
0
          Z_ADDREF(generator->value);
21492
0
        }
21493
5
      } else if (IS_TMP_VAR == IS_TMP_VAR) {
21494
5
        ZVAL_COPY_VALUE(&generator->value, value);
21495
5
      } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21496
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21497
21498
0
      } else {
21499
0
        ZVAL_COPY_VALUE(&generator->value, value);
21500
0
        if (IS_TMP_VAR == IS_CV) {
21501
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21502
0
        }
21503
0
      }
21504
5
    }
21505
5
  } else {
21506
    /* If no value was specified yield null */
21507
0
    ZVAL_NULL(&generator->value);
21508
0
  }
21509
21510
  /* Set the new yielded key */
21511
5
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
21512
5
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21513
5
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21514
0
      key = Z_REFVAL_P(key);
21515
0
    }
21516
5
    ZVAL_COPY(&generator->key, key);
21517
5
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21518
21519
5
    if (Z_TYPE(generator->key) == IS_LONG
21520
5
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
21521
5
    ) {
21522
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
21523
0
    }
21524
5
  } else {
21525
    /* If no key was specified we use auto-increment keys */
21526
0
    generator->largest_used_integer_key++;
21527
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21528
0
  }
21529
21530
5
  if (RETURN_VALUE_USED(opline)) {
21531
    /* If the return value of yield is used set the send
21532
     * target and initialize it to NULL */
21533
0
    generator->send_target = EX_VAR(opline->result.var);
21534
0
    ZVAL_NULL(generator->send_target);
21535
5
  } else {
21536
5
    generator->send_target = NULL;
21537
5
  }
21538
21539
  /* The GOTO VM uses a local opline variable. We need to set the opline
21540
   * variable in execute_data so we don't resume at an old position. */
21541
5
  SAVE_OPLINE();
21542
21543
5
  ZEND_VM_RETURN();
21544
5
}
21545
21546
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21547
203
{
21548
203
  USE_OPLINE
21549
203
  zval *op1, *op2;
21550
203
  bool result;
21551
21552
203
  SAVE_OPLINE();
21553
203
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21554
203
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21555
203
  result = fast_is_identical_function(op1, op2);
21556
203
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21557
203
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21558
203
  ZEND_VM_SMART_BRANCH(result, 1);
21559
203
}
21560
21561
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21562
217
{
21563
217
  USE_OPLINE
21564
217
  zval *op1, *op2;
21565
217
  bool result;
21566
21567
217
  SAVE_OPLINE();
21568
217
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21569
217
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21570
217
  result = fast_is_identical_function(op1, op2);
21571
217
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21572
217
  ZEND_VM_SMART_BRANCH(result, 1);
21573
217
}
21574
21575
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21576
2
{
21577
2
  USE_OPLINE
21578
2
  zval *op1, *op2;
21579
2
  bool result;
21580
21581
2
  SAVE_OPLINE();
21582
2
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21583
2
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21584
2
  result = fast_is_not_identical_function(op1, op2);
21585
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21586
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21587
2
  ZEND_VM_SMART_BRANCH(result, 1);
21588
2
}
21589
21590
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21591
0
{
21592
0
  USE_OPLINE
21593
0
  zval *op1, *op2;
21594
0
  bool result;
21595
21596
0
  SAVE_OPLINE();
21597
0
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21598
0
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
21599
0
  result = fast_is_identical_function(op1, op2);
21600
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21601
0
  ZEND_VM_SMART_BRANCH(result, 1);
21602
0
}
21603
21604
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21605
0
{
21606
#if 0
21607
  USE_OPLINE
21608
#endif
21609
21610
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21611
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21612
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21613
0
    }
21614
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21615
0
  } else {
21616
0
    if (IS_UNUSED == IS_UNUSED) {
21617
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21618
0
    }
21619
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21620
0
  }
21621
0
}
21622
21623
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21624
267
{
21625
267
  if (IS_TMP_VAR == IS_UNUSED) {
21626
0
    SAVE_OPLINE();
21627
0
    zend_verify_missing_return_type(EX(func));
21628
0
    HANDLE_EXCEPTION();
21629
267
  } else {
21630
/* prevents "undefined variable opline" errors */
21631
267
#if 0 || (IS_TMP_VAR != IS_UNUSED)
21632
267
    USE_OPLINE
21633
267
    zval *retval_ref, *retval_ptr;
21634
267
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
21635
267
    retval_ref = retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21636
21637
267
    if (IS_TMP_VAR == IS_CONST) {
21638
0
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
21639
0
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
21640
267
    } else if (IS_TMP_VAR == IS_VAR) {
21641
0
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
21642
0
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
21643
0
      }
21644
0
      ZVAL_DEREF(retval_ptr);
21645
267
    } else if (IS_TMP_VAR == IS_CV) {
21646
0
      ZVAL_DEREF(retval_ptr);
21647
0
    }
21648
21649
267
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
21650
184
      ZEND_VM_NEXT_OPCODE();
21651
184
    }
21652
21653
83
    if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
21654
0
      SAVE_OPLINE();
21655
0
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
21656
0
      if (UNEXPECTED(EG(exception))) {
21657
0
        HANDLE_EXCEPTION();
21658
0
      }
21659
0
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
21660
0
        ZEND_VM_NEXT_OPCODE();
21661
0
      }
21662
0
    }
21663
21664
83
    zend_reference *ref = NULL;
21665
83
    if (UNEXPECTED(retval_ref != retval_ptr)) {
21666
0
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21667
0
        ref = Z_REF_P(retval_ref);
21668
0
      } else {
21669
        /* A cast might happen - unwrap the reference if this is a by-value return */
21670
0
        if (Z_REFCOUNT_P(retval_ref) == 1) {
21671
0
          ZVAL_UNREF(retval_ref);
21672
0
        } else {
21673
0
          Z_DELREF_P(retval_ref);
21674
0
          ZVAL_COPY(retval_ref, retval_ptr);
21675
0
        }
21676
0
        retval_ptr = retval_ref;
21677
0
      }
21678
0
    }
21679
21680
83
    SAVE_OPLINE();
21681
83
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
21682
33
      zend_verify_return_error(EX(func), retval_ptr);
21683
33
      HANDLE_EXCEPTION();
21684
33
    }
21685
50
    ZEND_VM_NEXT_OPCODE();
21686
50
#endif
21687
50
  }
21688
267
}
21689
21690
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21691
0
{
21692
0
  USE_OPLINE
21693
0
  zval *value, *arg;
21694
0
  uint32_t arg_num;
21695
21696
0
  if (IS_UNUSED == IS_CONST) {
21697
0
    SAVE_OPLINE();
21698
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21699
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21700
0
    if (UNEXPECTED(!arg)) {
21701
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21702
0
      HANDLE_EXCEPTION();
21703
0
    }
21704
0
  } else {
21705
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21706
0
    arg_num = opline->op2.num;
21707
0
  }
21708
21709
0
  if (EXPECTED(0)) {
21710
0
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21711
0
      goto send_val_by_ref;
21712
0
    }
21713
0
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21714
0
send_val_by_ref:
21715
0
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
21716
0
  }
21717
0
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21718
0
  ZVAL_COPY_VALUE(arg, value);
21719
0
  if (IS_TMP_VAR == IS_CONST) {
21720
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21721
0
      Z_ADDREF_P(arg);
21722
0
    }
21723
0
  }
21724
0
  ZEND_VM_NEXT_OPCODE();
21725
0
}
21726
21727
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21728
4.75k
{
21729
4.75k
  USE_OPLINE
21730
4.75k
  zval *value, *arg;
21731
4.75k
  uint32_t arg_num;
21732
21733
4.75k
  if (IS_UNUSED == IS_CONST) {
21734
0
    SAVE_OPLINE();
21735
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21736
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21737
0
    if (UNEXPECTED(!arg)) {
21738
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21739
0
      HANDLE_EXCEPTION();
21740
0
    }
21741
4.75k
  } else {
21742
4.75k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21743
4.75k
    arg_num = opline->op2.num;
21744
4.75k
  }
21745
21746
4.75k
  if (EXPECTED(1)) {
21747
4.75k
    if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21748
77
      goto send_val_by_ref;
21749
77
    }
21750
4.75k
  } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21751
77
send_val_by_ref:
21752
77
    ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg));
21753
0
  }
21754
4.67k
  value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21755
4.67k
  ZVAL_COPY_VALUE(arg, value);
21756
4.67k
  if (IS_TMP_VAR == IS_CONST) {
21757
0
    if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21758
0
      Z_ADDREF_P(arg);
21759
0
    }
21760
0
  }
21761
4.67k
  ZEND_VM_NEXT_OPCODE();
21762
4.67k
}
21763
21764
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21765
9.91k
{
21766
9.91k
  USE_OPLINE
21767
9.91k
  zval *expr_ptr, new_expr;
21768
21769
9.91k
  SAVE_OPLINE();
21770
9.91k
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21771
9.91k
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21772
0
    expr_ptr = zend_get_bad_ptr();
21773
0
    if (Z_ISREF_P(expr_ptr)) {
21774
0
      Z_ADDREF_P(expr_ptr);
21775
0
    } else {
21776
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
21777
0
    }
21778
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21779
9.91k
  } else {
21780
9.91k
    expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21781
9.91k
    if (IS_TMP_VAR == IS_TMP_VAR) {
21782
      /* pass */
21783
9.91k
    } else if (IS_TMP_VAR == IS_CONST) {
21784
0
      Z_TRY_ADDREF_P(expr_ptr);
21785
0
    } else if (IS_TMP_VAR == IS_CV) {
21786
0
      ZVAL_DEREF(expr_ptr);
21787
0
      Z_TRY_ADDREF_P(expr_ptr);
21788
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
21789
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21790
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21791
21792
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
21793
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21794
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21795
0
          expr_ptr = &new_expr;
21796
0
          efree_size(ref, sizeof(zend_reference));
21797
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21798
0
          Z_ADDREF_P(expr_ptr);
21799
0
        }
21800
0
      }
21801
0
    }
21802
9.91k
  }
21803
21804
9.91k
  if (IS_UNUSED != IS_UNUSED) {
21805
0
    zval *offset = NULL;
21806
0
    zend_string *str;
21807
0
    zend_ulong hval;
21808
21809
0
add_again:
21810
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21811
0
      str = Z_STR_P(offset);
21812
0
      if (IS_UNUSED != IS_CONST) {
21813
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
21814
0
          goto num_index;
21815
0
        }
21816
0
      }
21817
0
str_index:
21818
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21819
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21820
0
      hval = Z_LVAL_P(offset);
21821
0
num_index:
21822
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21823
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21824
0
      offset = Z_REFVAL_P(offset);
21825
0
      goto add_again;
21826
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
21827
0
      str = ZSTR_EMPTY_ALLOC();
21828
0
      goto str_index;
21829
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21830
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21831
0
      goto num_index;
21832
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
21833
0
      hval = 0;
21834
0
      goto num_index;
21835
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
21836
0
      hval = 1;
21837
0
      goto num_index;
21838
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21839
0
      zend_use_resource_as_offset(offset);
21840
0
      hval = Z_RES_HANDLE_P(offset);
21841
0
      goto num_index;
21842
0
    } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21843
0
      ZVAL_UNDEFINED_OP2();
21844
0
      str = ZSTR_EMPTY_ALLOC();
21845
0
      goto str_index;
21846
0
    } else {
21847
0
      zend_illegal_array_offset_access(offset);
21848
0
      zval_ptr_dtor_nogc(expr_ptr);
21849
0
    }
21850
21851
9.91k
  } else {
21852
9.91k
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21853
0
      zend_cannot_add_element();
21854
0
      zval_ptr_dtor_nogc(expr_ptr);
21855
0
    }
21856
9.91k
  }
21857
9.91k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21858
9.91k
}
21859
21860
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21861
1.74k
{
21862
1.74k
  zval *array;
21863
1.74k
  uint32_t size;
21864
1.74k
  USE_OPLINE
21865
21866
1.74k
  SAVE_OPLINE();
21867
1.74k
  array = EX_VAR(opline->result.var);
21868
1.74k
  if (IS_TMP_VAR != IS_UNUSED) {
21869
1.74k
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21870
1.74k
    ZVAL_ARR(array, zend_new_array(size));
21871
    /* Explicitly initialize array as not-packed if flag is set */
21872
1.74k
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21873
52
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21874
52
    }
21875
1.74k
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21876
1.74k
  } else {
21877
0
    ZVAL_ARR(array, zend_new_array(0));
21878
0
    ZEND_VM_NEXT_OPCODE();
21879
0
  }
21880
1.74k
}
21881
21882
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21883
522
{
21884
522
  USE_OPLINE
21885
21886
522
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21887
21888
522
  SAVE_OPLINE();
21889
522
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21890
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21891
0
  }
21892
21893
  /* Destroy the previously yielded value */
21894
522
  zval_ptr_dtor(&generator->value);
21895
21896
  /* Destroy the previously yielded key */
21897
522
  zval_ptr_dtor(&generator->key);
21898
21899
  /* Set the new yielded value */
21900
522
  if (IS_TMP_VAR != IS_UNUSED) {
21901
522
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21902
      /* Constants and temporary variables aren't yieldable by reference,
21903
       * but we still allow them with a notice. */
21904
12
      if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21905
12
        zval *value;
21906
21907
12
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21908
21909
12
        value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21910
12
        ZVAL_COPY_VALUE(&generator->value, value);
21911
12
        if (IS_TMP_VAR == IS_CONST) {
21912
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21913
0
            Z_ADDREF(generator->value);
21914
0
          }
21915
0
        }
21916
12
      } else {
21917
0
        zval *value_ptr = zend_get_bad_ptr();
21918
21919
        /* If a function call result is yielded and the function did
21920
         * not return by reference we throw a notice. */
21921
0
        do {
21922
0
          if (IS_TMP_VAR == IS_VAR) {
21923
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21924
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
21925
0
             && !Z_ISREF_P(value_ptr)) {
21926
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21927
0
              ZVAL_COPY(&generator->value, value_ptr);
21928
0
              break;
21929
0
            }
21930
0
          }
21931
0
          if (Z_ISREF_P(value_ptr)) {
21932
0
            Z_ADDREF_P(value_ptr);
21933
0
          } else {
21934
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
21935
0
          }
21936
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21937
0
        } while (0);
21938
21939
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21940
0
      }
21941
510
    } else {
21942
510
      zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21943
21944
      /* Consts, temporary variables and references need copying */
21945
510
      if (IS_TMP_VAR == IS_CONST) {
21946
0
        ZVAL_COPY_VALUE(&generator->value, value);
21947
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21948
0
          Z_ADDREF(generator->value);
21949
0
        }
21950
510
      } else if (IS_TMP_VAR == IS_TMP_VAR) {
21951
510
        ZVAL_COPY_VALUE(&generator->value, value);
21952
510
      } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21953
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21954
21955
0
      } else {
21956
0
        ZVAL_COPY_VALUE(&generator->value, value);
21957
0
        if (IS_TMP_VAR == IS_CV) {
21958
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21959
0
        }
21960
0
      }
21961
510
    }
21962
522
  } else {
21963
    /* If no value was specified yield null */
21964
0
    ZVAL_NULL(&generator->value);
21965
0
  }
21966
21967
  /* Set the new yielded key */
21968
522
  if (IS_UNUSED != IS_UNUSED) {
21969
0
    zval *key = NULL;
21970
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21971
0
      key = Z_REFVAL_P(key);
21972
0
    }
21973
0
    ZVAL_COPY(&generator->key, key);
21974
21975
0
    if (Z_TYPE(generator->key) == IS_LONG
21976
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
21977
0
    ) {
21978
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
21979
0
    }
21980
522
  } else {
21981
    /* If no key was specified we use auto-increment keys */
21982
522
    generator->largest_used_integer_key++;
21983
522
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21984
522
  }
21985
21986
522
  if (RETURN_VALUE_USED(opline)) {
21987
    /* If the return value of yield is used set the send
21988
     * target and initialize it to NULL */
21989
122
    generator->send_target = EX_VAR(opline->result.var);
21990
122
    ZVAL_NULL(generator->send_target);
21991
400
  } else {
21992
400
    generator->send_target = NULL;
21993
400
  }
21994
21995
  /* The GOTO VM uses a local opline variable. We need to set the opline
21996
   * variable in execute_data so we don't resume at an old position. */
21997
522
  SAVE_OPLINE();
21998
21999
522
  ZEND_VM_RETURN();
22000
522
}
22001
22002
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22003
162
{
22004
162
  USE_OPLINE
22005
162
  zval *op1;
22006
162
  zend_string *type;
22007
22008
162
  SAVE_OPLINE();
22009
162
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22010
162
  type = zend_zval_get_legacy_type(op1);
22011
162
  if (EXPECTED(type)) {
22012
162
    ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
22013
162
  } else {
22014
0
    ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
22015
0
  }
22016
162
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22017
162
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22018
162
}
22019
22020
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22021
0
{
22022
0
  USE_OPLINE
22023
0
  zval *op1, *op2;
22024
0
  bool result;
22025
22026
0
  SAVE_OPLINE();
22027
0
  op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22028
0
  op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22029
0
  result = fast_is_identical_function(op1, op2);
22030
22031
0
  ZEND_VM_SMART_BRANCH(result, 1);
22032
0
}
22033
22034
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22035
0
{
22036
#if 0
22037
  USE_OPLINE
22038
#endif
22039
22040
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
22041
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
22042
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22043
0
    }
22044
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22045
0
  } else {
22046
0
    if (IS_CV == IS_UNUSED) {
22047
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22048
0
    }
22049
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22050
0
  }
22051
0
}
22052
22053
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22054
0
{
22055
#if 0
22056
  USE_OPLINE
22057
#endif
22058
22059
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
22060
    /* Behave like FETCH_OBJ_W */
22061
0
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
22062
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22063
0
    }
22064
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22065
0
  } else {
22066
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22067
0
  }
22068
0
}
22069
22070
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22071
642k
{
22072
642k
  USE_OPLINE
22073
642k
  zend_string **rope;
22074
642k
  zval *var;
22075
22076
  /* op1 and result are the same */
22077
642k
  rope = (zend_string**)EX_VAR(opline->op1.var);
22078
642k
  if (IS_CV == IS_CONST) {
22079
0
    var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22080
0
    rope[opline->extended_value] = Z_STR_P(var);
22081
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
22082
0
      Z_ADDREF_P(var);
22083
0
    }
22084
642k
  } else {
22085
642k
    var = EX_VAR(opline->op2.var);
22086
642k
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
22087
212k
      if (IS_CV == IS_CV) {
22088
212k
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
22089
212k
      } else {
22090
0
        rope[opline->extended_value] = Z_STR_P(var);
22091
0
      }
22092
429k
    } else {
22093
429k
      SAVE_OPLINE();
22094
429k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
22095
410k
        ZVAL_UNDEFINED_OP2();
22096
410k
      }
22097
429k
      rope[opline->extended_value] = zval_get_string_func(var);
22098
22099
429k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22100
429k
    }
22101
642k
  }
22102
212k
  ZEND_VM_NEXT_OPCODE();
22103
212k
}
22104
22105
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22106
3.17k
{
22107
3.17k
  USE_OPLINE
22108
3.17k
  zend_string **rope;
22109
3.17k
  zval *var, *ret;
22110
3.17k
  uint32_t i;
22111
22112
3.17k
  rope = (zend_string**)EX_VAR(opline->op1.var);
22113
3.17k
  if (IS_CV == IS_CONST) {
22114
0
    var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22115
0
    rope[opline->extended_value] = Z_STR_P(var);
22116
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
22117
0
      Z_ADDREF_P(var);
22118
0
    }
22119
3.17k
  } else {
22120
3.17k
    var = EX_VAR(opline->op2.var);
22121
3.17k
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
22122
26
      if (IS_CV == IS_CV) {
22123
26
        rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
22124
26
      } else {
22125
0
        rope[opline->extended_value] = Z_STR_P(var);
22126
0
      }
22127
3.15k
    } else {
22128
3.15k
      SAVE_OPLINE();
22129
3.15k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
22130
2.79k
        ZVAL_UNDEFINED_OP2();
22131
2.79k
      }
22132
3.15k
      rope[opline->extended_value] = zval_get_string_func(var);
22133
22134
3.15k
      if (UNEXPECTED(EG(exception))) {
22135
96
        for (i = 0; i <= opline->extended_value; i++) {
22136
72
          zend_string_release_ex(rope[i], 0);
22137
72
        }
22138
24
        ZVAL_UNDEF(EX_VAR(opline->result.var));
22139
24
        HANDLE_EXCEPTION();
22140
24
      }
22141
3.15k
    }
22142
3.17k
  }
22143
22144
3.15k
  size_t len = 0;
22145
3.15k
  uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
22146
42.7k
  for (i = 0; i <= opline->extended_value; i++) {
22147
39.6k
    flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
22148
39.6k
    len += ZSTR_LEN(rope[i]);
22149
39.6k
  }
22150
3.15k
  ret = EX_VAR(opline->result.var);
22151
3.15k
  ZVAL_STR(ret, zend_string_alloc(len, 0));
22152
3.15k
  GC_ADD_FLAGS(Z_STR_P(ret), flags);
22153
22154
3.15k
  char *target = Z_STRVAL_P(ret);
22155
42.7k
  for (i = 0; i <= opline->extended_value; i++) {
22156
39.6k
    memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
22157
39.6k
    target += ZSTR_LEN(rope[i]);
22158
39.6k
    zend_string_release_ex(rope[i], 0);
22159
39.6k
  }
22160
3.15k
  *target = '\0';
22161
22162
3.15k
  ZEND_VM_NEXT_OPCODE();
22163
3.15k
}
22164
22165
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22166
0
{
22167
0
  USE_OPLINE
22168
0
  zval *expr_ptr, new_expr;
22169
22170
0
  SAVE_OPLINE();
22171
0
  if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
22172
0
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
22173
0
    expr_ptr = zend_get_bad_ptr();
22174
0
    if (Z_ISREF_P(expr_ptr)) {
22175
0
      Z_ADDREF_P(expr_ptr);
22176
0
    } else {
22177
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
22178
0
    }
22179
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22180
0
  } else {
22181
0
    expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22182
0
    if (IS_TMP_VAR == IS_TMP_VAR) {
22183
      /* pass */
22184
0
    } else if (IS_TMP_VAR == IS_CONST) {
22185
0
      Z_TRY_ADDREF_P(expr_ptr);
22186
0
    } else if (IS_TMP_VAR == IS_CV) {
22187
0
      ZVAL_DEREF(expr_ptr);
22188
0
      Z_TRY_ADDREF_P(expr_ptr);
22189
0
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
22190
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
22191
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
22192
22193
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
22194
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22195
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
22196
0
          expr_ptr = &new_expr;
22197
0
          efree_size(ref, sizeof(zend_reference));
22198
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
22199
0
          Z_ADDREF_P(expr_ptr);
22200
0
        }
22201
0
      }
22202
0
    }
22203
0
  }
22204
22205
0
  if (IS_CV != IS_UNUSED) {
22206
0
    zval *offset = EX_VAR(opline->op2.var);
22207
0
    zend_string *str;
22208
0
    zend_ulong hval;
22209
22210
0
add_again:
22211
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
22212
0
      str = Z_STR_P(offset);
22213
0
      if (IS_CV != IS_CONST) {
22214
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
22215
0
          goto num_index;
22216
0
        }
22217
0
      }
22218
0
str_index:
22219
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
22220
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
22221
0
      hval = Z_LVAL_P(offset);
22222
0
num_index:
22223
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
22224
0
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
22225
0
      offset = Z_REFVAL_P(offset);
22226
0
      goto add_again;
22227
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
22228
0
      str = ZSTR_EMPTY_ALLOC();
22229
0
      goto str_index;
22230
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
22231
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
22232
0
      goto num_index;
22233
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
22234
0
      hval = 0;
22235
0
      goto num_index;
22236
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
22237
0
      hval = 1;
22238
0
      goto num_index;
22239
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
22240
0
      zend_use_resource_as_offset(offset);
22241
0
      hval = Z_RES_HANDLE_P(offset);
22242
0
      goto num_index;
22243
0
    } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
22244
0
      ZVAL_UNDEFINED_OP2();
22245
0
      str = ZSTR_EMPTY_ALLOC();
22246
0
      goto str_index;
22247
0
    } else {
22248
0
      zend_illegal_array_offset_access(offset);
22249
0
      zval_ptr_dtor_nogc(expr_ptr);
22250
0
    }
22251
22252
0
  } else {
22253
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
22254
0
      zend_cannot_add_element();
22255
0
      zval_ptr_dtor_nogc(expr_ptr);
22256
0
    }
22257
0
  }
22258
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22259
0
}
22260
22261
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22262
0
{
22263
0
  zval *array;
22264
0
  uint32_t size;
22265
0
  USE_OPLINE
22266
22267
0
  SAVE_OPLINE();
22268
0
  array = EX_VAR(opline->result.var);
22269
0
  if (IS_TMP_VAR != IS_UNUSED) {
22270
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
22271
0
    ZVAL_ARR(array, zend_new_array(size));
22272
    /* Explicitly initialize array as not-packed if flag is set */
22273
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
22274
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
22275
0
    }
22276
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22277
0
  } else {
22278
0
    ZVAL_ARR(array, zend_new_array(0));
22279
0
    ZEND_VM_NEXT_OPCODE();
22280
0
  }
22281
0
}
22282
22283
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22284
0
{
22285
0
  USE_OPLINE
22286
22287
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22288
22289
0
  SAVE_OPLINE();
22290
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
22291
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22292
0
  }
22293
22294
  /* Destroy the previously yielded value */
22295
0
  zval_ptr_dtor(&generator->value);
22296
22297
  /* Destroy the previously yielded key */
22298
0
  zval_ptr_dtor(&generator->key);
22299
22300
  /* Set the new yielded value */
22301
0
  if (IS_TMP_VAR != IS_UNUSED) {
22302
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
22303
      /* Constants and temporary variables aren't yieldable by reference,
22304
       * but we still allow them with a notice. */
22305
0
      if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
22306
0
        zval *value;
22307
22308
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22309
22310
0
        value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22311
0
        ZVAL_COPY_VALUE(&generator->value, value);
22312
0
        if (IS_TMP_VAR == IS_CONST) {
22313
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
22314
0
            Z_ADDREF(generator->value);
22315
0
          }
22316
0
        }
22317
0
      } else {
22318
0
        zval *value_ptr = zend_get_bad_ptr();
22319
22320
        /* If a function call result is yielded and the function did
22321
         * not return by reference we throw a notice. */
22322
0
        do {
22323
0
          if (IS_TMP_VAR == IS_VAR) {
22324
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
22325
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
22326
0
             && !Z_ISREF_P(value_ptr)) {
22327
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22328
0
              ZVAL_COPY(&generator->value, value_ptr);
22329
0
              break;
22330
0
            }
22331
0
          }
22332
0
          if (Z_ISREF_P(value_ptr)) {
22333
0
            Z_ADDREF_P(value_ptr);
22334
0
          } else {
22335
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
22336
0
          }
22337
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
22338
0
        } while (0);
22339
22340
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22341
0
      }
22342
0
    } else {
22343
0
      zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22344
22345
      /* Consts, temporary variables and references need copying */
22346
0
      if (IS_TMP_VAR == IS_CONST) {
22347
0
        ZVAL_COPY_VALUE(&generator->value, value);
22348
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
22349
0
          Z_ADDREF(generator->value);
22350
0
        }
22351
0
      } else if (IS_TMP_VAR == IS_TMP_VAR) {
22352
0
        ZVAL_COPY_VALUE(&generator->value, value);
22353
0
      } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
22354
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
22355
22356
0
      } else {
22357
0
        ZVAL_COPY_VALUE(&generator->value, value);
22358
0
        if (IS_TMP_VAR == IS_CV) {
22359
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
22360
0
        }
22361
0
      }
22362
0
    }
22363
0
  } else {
22364
    /* If no value was specified yield null */
22365
0
    ZVAL_NULL(&generator->value);
22366
0
  }
22367
22368
  /* Set the new yielded key */
22369
0
  if (IS_CV != IS_UNUSED) {
22370
0
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22371
0
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
22372
0
      key = Z_REFVAL_P(key);
22373
0
    }
22374
0
    ZVAL_COPY(&generator->key, key);
22375
22376
0
    if (Z_TYPE(generator->key) == IS_LONG
22377
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
22378
0
    ) {
22379
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
22380
0
    }
22381
0
  } else {
22382
    /* If no key was specified we use auto-increment keys */
22383
0
    generator->largest_used_integer_key++;
22384
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
22385
0
  }
22386
22387
0
  if (RETURN_VALUE_USED(opline)) {
22388
    /* If the return value of yield is used set the send
22389
     * target and initialize it to NULL */
22390
0
    generator->send_target = EX_VAR(opline->result.var);
22391
0
    ZVAL_NULL(generator->send_target);
22392
0
  } else {
22393
0
    generator->send_target = NULL;
22394
0
  }
22395
22396
  /* The GOTO VM uses a local opline variable. We need to set the opline
22397
   * variable in execute_data so we don't resume at an old position. */
22398
0
  SAVE_OPLINE();
22399
22400
0
  ZEND_VM_RETURN();
22401
0
}
22402
22403
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22404
5.78k
{
22405
5.78k
  USE_OPLINE
22406
5.78k
  zval *closure, *var;
22407
22408
5.78k
  closure = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22409
5.78k
  if (opline->extended_value & ZEND_BIND_REF) {
22410
    /* By-ref binding */
22411
959
    var = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
22412
959
    if (Z_ISREF_P(var)) {
22413
283
      Z_ADDREF_P(var);
22414
676
    } else {
22415
676
      ZVAL_MAKE_REF_EX(var, 2);
22416
676
    }
22417
4.82k
  } else {
22418
4.82k
    var = EX_VAR(opline->op2.var);
22419
4.82k
    if (UNEXPECTED(Z_ISUNDEF_P(var)) && !(opline->extended_value & ZEND_BIND_IMPLICIT)) {
22420
220
      SAVE_OPLINE();
22421
220
      var = ZVAL_UNDEFINED_OP2();
22422
220
      if (UNEXPECTED(EG(exception))) {
22423
0
        HANDLE_EXCEPTION();
22424
0
      }
22425
220
    }
22426
4.82k
    ZVAL_DEREF(var);
22427
4.82k
    Z_TRY_ADDREF_P(var);
22428
4.82k
  }
22429
22430
5.78k
  zend_closure_bind_var_ex(closure,
22431
5.78k
    (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT)), var);
22432
5.78k
  ZEND_VM_NEXT_OPCODE();
22433
5.78k
}
22434
22435
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22436
167
{
22437
167
  USE_OPLINE
22438
167
  zval *var_ptr;
22439
22440
167
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22441
22442
167
  SAVE_OPLINE();
22443
167
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22444
0
    ZVAL_UNDEFINED_OP1();
22445
0
    ZVAL_NULL(var_ptr);
22446
0
  }
22447
22448
167
  do {
22449
167
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22450
53
      zend_reference *ref = Z_REF_P(var_ptr);
22451
53
      var_ptr = Z_REFVAL_P(var_ptr);
22452
53
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22453
35
        zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
22454
35
        break;
22455
35
      }
22456
53
    }
22457
132
    increment_function(var_ptr);
22458
132
  } while (0);
22459
22460
167
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
22461
7
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22462
7
  }
22463
22464
167
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22465
167
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22466
167
}
22467
22468
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22469
765
{
22470
765
  USE_OPLINE
22471
765
  zval *var_ptr;
22472
22473
765
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22474
22475
765
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22476
605
    fast_long_increment_function(var_ptr);
22477
605
    if (UNEXPECTED(0)) {
22478
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22479
0
    }
22480
605
    ZEND_VM_NEXT_OPCODE();
22481
605
  }
22482
22483
765
  ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22484
765
}
22485
22486
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22487
7
{
22488
7
  USE_OPLINE
22489
7
  zval *var_ptr;
22490
22491
7
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22492
22493
7
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22494
0
    fast_long_increment_function(var_ptr);
22495
0
    if (UNEXPECTED(1)) {
22496
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22497
0
    }
22498
0
    ZEND_VM_NEXT_OPCODE();
22499
0
  }
22500
22501
7
  ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22502
7
}
22503
22504
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22505
176
{
22506
176
  USE_OPLINE
22507
176
  zval *var_ptr;
22508
22509
176
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22510
22511
176
  SAVE_OPLINE();
22512
176
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22513
0
    ZVAL_UNDEFINED_OP1();
22514
0
    ZVAL_NULL(var_ptr);
22515
0
  }
22516
22517
176
  do {
22518
176
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22519
87
      zend_reference *ref = Z_REF_P(var_ptr);
22520
87
      var_ptr = Z_REFVAL_P(var_ptr);
22521
22522
87
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22523
87
        zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
22524
87
        break;
22525
87
      }
22526
87
    }
22527
89
    decrement_function(var_ptr);
22528
89
  } while (0);
22529
22530
176
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
22531
83
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22532
83
  }
22533
22534
176
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22535
176
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22536
176
}
22537
22538
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22539
98
{
22540
98
  USE_OPLINE
22541
98
  zval *var_ptr;
22542
22543
98
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22544
22545
98
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22546
5
    fast_long_decrement_function(var_ptr);
22547
5
    if (UNEXPECTED(0)) {
22548
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22549
0
    }
22550
5
    ZEND_VM_NEXT_OPCODE();
22551
5
  }
22552
22553
98
  ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22554
98
}
22555
22556
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22557
129
{
22558
129
  USE_OPLINE
22559
129
  zval *var_ptr;
22560
22561
129
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22562
22563
129
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22564
46
    fast_long_decrement_function(var_ptr);
22565
46
    if (UNEXPECTED(1)) {
22566
46
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22567
46
    }
22568
46
    ZEND_VM_NEXT_OPCODE();
22569
46
  }
22570
22571
129
  ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22572
129
}
22573
22574
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22575
5
{
22576
5
  USE_OPLINE
22577
5
  zval *var_ptr;
22578
22579
5
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22580
22581
5
  SAVE_OPLINE();
22582
5
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22583
0
    ZVAL_UNDEFINED_OP1();
22584
0
    ZVAL_NULL(var_ptr);
22585
0
  }
22586
22587
5
  do {
22588
5
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22589
0
      zend_reference *ref = Z_REF_P(var_ptr);
22590
0
      var_ptr = Z_REFVAL_P(var_ptr);
22591
22592
0
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22593
0
        zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
22594
0
        break;
22595
0
      }
22596
0
    }
22597
5
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22598
22599
5
    increment_function(var_ptr);
22600
5
  } while (0);
22601
22602
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22603
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22604
5
}
22605
22606
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22607
5
{
22608
5
  USE_OPLINE
22609
5
  zval *var_ptr;
22610
22611
5
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22612
22613
5
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22614
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
22615
0
    fast_long_increment_function(var_ptr);
22616
0
    ZEND_VM_NEXT_OPCODE();
22617
0
  }
22618
22619
5
  ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22620
5
}
22621
22622
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22623
83
{
22624
83
  USE_OPLINE
22625
83
  zval *var_ptr;
22626
22627
83
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22628
22629
83
  SAVE_OPLINE();
22630
83
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22631
0
    ZVAL_UNDEFINED_OP1();
22632
0
    ZVAL_NULL(var_ptr);
22633
0
  }
22634
22635
83
  do {
22636
83
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22637
0
      zend_reference *ref = Z_REF_P(var_ptr);
22638
0
      var_ptr = Z_REFVAL_P(var_ptr);
22639
22640
0
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22641
0
        zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
22642
0
        break;
22643
0
      }
22644
0
    }
22645
83
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22646
22647
83
    decrement_function(var_ptr);
22648
83
  } while (0);
22649
22650
83
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22651
83
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22652
83
}
22653
22654
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22655
83
{
22656
83
  USE_OPLINE
22657
83
  zval *var_ptr;
22658
22659
83
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22660
22661
83
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22662
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
22663
0
    fast_long_decrement_function(var_ptr);
22664
0
    ZEND_VM_NEXT_OPCODE();
22665
0
  }
22666
22667
83
  ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22668
83
}
22669
22670
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22671
5.18k
{
22672
5.18k
  USE_OPLINE
22673
5.18k
  zval *retval_ptr;
22674
5.18k
  zval *return_value;
22675
22676
5.18k
  retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22677
5.18k
  return_value = EX(return_value);
22678
22679
5.18k
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
22680
0
    SAVE_OPLINE();
22681
0
    retval_ptr = ZVAL_UNDEFINED_OP1();
22682
0
    if (return_value) {
22683
0
      ZVAL_NULL(return_value);
22684
0
    }
22685
5.18k
  } else if (!return_value) {
22686
338
    if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
22687
338
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
22688
221
        SAVE_OPLINE();
22689
221
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
22690
221
      }
22691
338
    }
22692
4.84k
  } else {
22693
4.84k
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22694
0
      ZVAL_COPY_VALUE(return_value, retval_ptr);
22695
0
      if (IS_VAR == IS_CONST) {
22696
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
22697
0
          Z_ADDREF_P(return_value);
22698
0
        }
22699
0
      }
22700
4.84k
    } else if (IS_VAR == IS_CV) {
22701
0
      do {
22702
0
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22703
0
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
22704
0
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
22705
0
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22706
0
              ZVAL_COPY_VALUE(return_value, retval_ptr);
22707
0
              if (GC_MAY_LEAK(ref)) {
22708
0
                SAVE_OPLINE();
22709
0
                gc_possible_root(ref);
22710
0
              }
22711
0
              ZVAL_NULL(retval_ptr);
22712
0
              break;
22713
0
            } else {
22714
0
              Z_ADDREF_P(retval_ptr);
22715
0
            }
22716
0
          } else {
22717
0
            retval_ptr = Z_REFVAL_P(retval_ptr);
22718
0
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22719
0
              Z_ADDREF_P(retval_ptr);
22720
0
            }
22721
0
          }
22722
0
        }
22723
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
22724
0
      } while (0);
22725
4.84k
    } else /* if (IS_VAR == IS_VAR) */ {
22726
4.84k
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22727
10
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22728
22729
10
        retval_ptr = Z_REFVAL_P(retval_ptr);
22730
10
        ZVAL_COPY_VALUE(return_value, retval_ptr);
22731
10
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22732
10
          efree_size(ref, sizeof(zend_reference));
22733
10
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22734
0
          Z_ADDREF_P(retval_ptr);
22735
0
        }
22736
4.83k
      } else {
22737
4.83k
        ZVAL_COPY_VALUE(return_value, retval_ptr);
22738
4.83k
      }
22739
4.84k
    }
22740
4.84k
  }
22741
22742
22743
22744
5.18k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22745
5.18k
}
22746
22747
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22748
1.03k
{
22749
1.03k
  USE_OPLINE
22750
1.03k
  zval *retval_ptr;
22751
1.03k
  zval *return_value;
22752
22753
1.03k
  SAVE_OPLINE();
22754
22755
1.03k
  return_value = EX(return_value);
22756
22757
1.03k
  do {
22758
1.03k
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR)) ||
22759
1.03k
        (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
22760
      /* Not supposed to happen, but we'll allow it */
22761
0
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
22762
22763
0
      retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22764
0
      if (!return_value) {
22765
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22766
0
      } else {
22767
0
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22768
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
22769
0
          break;
22770
0
        }
22771
22772
0
        ZVAL_NEW_REF(return_value, retval_ptr);
22773
0
        if (IS_VAR == IS_CONST) {
22774
0
          Z_TRY_ADDREF_P(retval_ptr);
22775
0
        }
22776
0
      }
22777
0
      break;
22778
0
    }
22779
22780
1.03k
    retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22781
22782
1.03k
    if (IS_VAR == IS_VAR) {
22783
1.03k
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
22784
1.03k
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
22785
15
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
22786
15
        if (return_value) {
22787
15
          ZVAL_NEW_REF(return_value, retval_ptr);
22788
15
        } else {
22789
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22790
0
        }
22791
15
        break;
22792
15
      }
22793
1.03k
    }
22794
22795
1.01k
    if (return_value) {
22796
1.01k
      if (Z_ISREF_P(retval_ptr)) {
22797
649
        Z_ADDREF_P(retval_ptr);
22798
649
      } else {
22799
369
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
22800
369
      }
22801
1.01k
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
22802
1.01k
    }
22803
22804
1.01k
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22805
1.01k
  } while (0);
22806
22807
22808
1.03k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22809
1.03k
}
22810
22811
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22812
12
{
22813
12
  USE_OPLINE
22814
12
  zval *retval;
22815
22816
12
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22817
22818
12
  SAVE_OPLINE();
22819
12
  retval = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22820
22821
  /* Copy return value into generator->retval */
22822
12
  if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22823
0
    ZVAL_COPY_VALUE(&generator->retval, retval);
22824
0
    if (IS_VAR == IS_CONST) {
22825
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
22826
0
        Z_ADDREF(generator->retval);
22827
0
      }
22828
0
    }
22829
12
  } else if (IS_VAR == IS_CV) {
22830
0
    ZVAL_COPY_DEREF(&generator->retval, retval);
22831
12
  } else /* if (IS_VAR == IS_VAR) */ {
22832
12
    if (UNEXPECTED(Z_ISREF_P(retval))) {
22833
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
22834
22835
0
      retval = Z_REFVAL_P(retval);
22836
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
22837
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22838
0
        efree_size(ref, sizeof(zend_reference));
22839
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
22840
0
        Z_ADDREF_P(retval);
22841
0
      }
22842
12
    } else {
22843
12
      ZVAL_COPY_VALUE(&generator->retval, retval);
22844
12
    }
22845
12
  }
22846
22847
12
  EG(current_execute_data) = EX(prev_execute_data);
22848
22849
  /* Close the generator to free up resources */
22850
12
  zend_generator_close(generator, 1);
22851
22852
  /* Pass execution back to handling code */
22853
12
  ZEND_VM_RETURN();
22854
12
}
22855
22856
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22857
5
{
22858
5
  USE_OPLINE
22859
5
  zval *arg, *param;
22860
22861
5
  SAVE_OPLINE();
22862
22863
5
  arg = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22864
5
  param = ZEND_CALL_VAR(EX(call), opline->result.var);
22865
5
  if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
22866
5
    zend_param_must_be_ref(EX(call)->func, opline->op2.num);
22867
5
    Z_TRY_ADDREF_P(arg);
22868
5
    ZVAL_NEW_REF(param, arg);
22869
5
  } else {
22870
0
    ZVAL_COPY(param, arg);
22871
0
  }
22872
22873
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22874
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22875
5
}
22876
22877
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22878
6.17k
{
22879
6.17k
  USE_OPLINE
22880
6.17k
  zval *expr;
22881
6.17k
  zval *result = EX_VAR(opline->result.var);
22882
22883
6.17k
  SAVE_OPLINE();
22884
6.17k
  expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22885
22886
6.17k
  switch (opline->extended_value) {
22887
33
    case IS_LONG:
22888
33
      ZVAL_LONG(result, zval_get_long(expr));
22889
33
      break;
22890
5.91k
    case IS_DOUBLE:
22891
5.91k
      ZVAL_DOUBLE(result, zval_get_double(expr));
22892
5.91k
      break;
22893
110
    case IS_STRING:
22894
110
      ZVAL_STR(result, zval_get_string(expr));
22895
110
      break;
22896
115
    default:
22897
115
      ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
22898
115
      if (IS_VAR & (IS_VAR|IS_CV)) {
22899
115
        ZVAL_DEREF(expr);
22900
115
      }
22901
      /* If value is already of correct type, return it directly */
22902
115
      if (Z_TYPE_P(expr) == opline->extended_value) {
22903
108
        ZVAL_COPY_VALUE(result, expr);
22904
108
        if (IS_VAR == IS_CONST) {
22905
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22906
108
        } else if (IS_VAR != IS_TMP_VAR) {
22907
108
          if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22908
108
        }
22909
22910
108
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22911
108
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22912
108
      }
22913
22914
7
      if (opline->extended_value == IS_ARRAY) {
22915
7
        zend_cast_zval_to_array(result, expr, IS_VAR);
22916
7
      } else {
22917
0
        ZEND_ASSERT(opline->extended_value == IS_OBJECT);
22918
0
        zend_cast_zval_to_object(result, expr, IS_VAR);
22919
0
      }
22920
6.17k
  }
22921
22922
6.06k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22923
6.06k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22924
6.06k
}
22925
22926
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22927
730
{
22928
730
  USE_OPLINE
22929
730
  zval *array_ptr, *result;
22930
22931
730
  SAVE_OPLINE();
22932
22933
730
  array_ptr = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22934
730
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22935
324
    result = EX_VAR(opline->result.var);
22936
324
    ZVAL_COPY_VALUE(result, array_ptr);
22937
324
    if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
22938
307
      Z_ADDREF_P(array_ptr);
22939
307
    }
22940
324
    Z_FE_POS_P(result) = 0;
22941
22942
324
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22943
324
    ZEND_VM_NEXT_OPCODE();
22944
406
  } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22945
406
    zend_object *zobj = Z_OBJ_P(array_ptr);
22946
406
    if (!zobj->ce->get_iterator) {
22947
24
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
22948
0
        zobj = zend_lazy_object_init(zobj);
22949
0
        if (UNEXPECTED(EG(exception))) {
22950
0
          UNDEF_RESULT();
22951
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22952
0
          HANDLE_EXCEPTION();
22953
0
        }
22954
0
      }
22955
24
      HashTable *properties = zobj->properties;
22956
24
      if (properties) {
22957
0
        if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
22958
0
          if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
22959
0
            GC_DELREF(properties);
22960
0
          }
22961
0
          properties = zobj->properties = zend_array_dup(properties);
22962
0
        }
22963
24
      } else {
22964
24
        properties = zobj->handlers->get_properties(zobj);
22965
24
      }
22966
22967
24
      result = EX_VAR(opline->result.var);
22968
24
      ZVAL_COPY_VALUE(result, array_ptr);
22969
24
      if (IS_VAR != IS_TMP_VAR) {
22970
24
        Z_ADDREF_P(array_ptr);
22971
24
      }
22972
22973
24
      if (zend_hash_num_elements(properties) == 0) {
22974
0
        Z_FE_ITER_P(result) = (uint32_t) -1;
22975
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22976
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22977
0
      }
22978
22979
24
      Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
22980
24
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22981
24
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22982
382
    } else {
22983
382
      bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
22984
22985
382
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22986
382
      if (UNEXPECTED(EG(exception))) {
22987
76
        HANDLE_EXCEPTION();
22988
306
      } else if (is_empty) {
22989
23
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22990
283
      } else {
22991
283
        ZEND_VM_NEXT_OPCODE();
22992
283
      }
22993
382
    }
22994
406
  } else {
22995
0
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22996
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
22997
0
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22998
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22999
0
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
23000
0
  }
23001
730
}
23002
23003
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23004
81
{
23005
81
  USE_OPLINE
23006
81
  zval *array_ptr, *array_ref;
23007
23008
81
  SAVE_OPLINE();
23009
23010
81
  if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
23011
81
    array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23012
81
    if (Z_ISREF_P(array_ref)) {
23013
14
      array_ptr = Z_REFVAL_P(array_ref);
23014
14
    }
23015
81
  } else {
23016
0
    array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23017
0
  }
23018
23019
81
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
23020
38
    if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
23021
38
      if (array_ptr == array_ref) {
23022
26
        ZVAL_NEW_REF(array_ref, array_ref);
23023
26
        array_ptr = Z_REFVAL_P(array_ref);
23024
26
      }
23025
38
      Z_ADDREF_P(array_ref);
23026
38
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
23027
38
    } else {
23028
0
      array_ref = EX_VAR(opline->result.var);
23029
0
      ZVAL_NEW_REF(array_ref, array_ptr);
23030
0
      array_ptr = Z_REFVAL_P(array_ref);
23031
0
    }
23032
38
    if (IS_VAR == IS_CONST) {
23033
0
      ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
23034
38
    } else {
23035
38
      SEPARATE_ARRAY(array_ptr);
23036
38
    }
23037
38
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
23038
23039
38
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23040
38
    ZEND_VM_NEXT_OPCODE();
23041
43
  } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
23042
34
    if (!Z_OBJCE_P(array_ptr)->get_iterator) {
23043
10
      zend_object *zobj = Z_OBJ_P(array_ptr);
23044
10
      HashTable *properties;
23045
10
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
23046
0
        zobj = zend_lazy_object_init(zobj);
23047
0
        if (UNEXPECTED(EG(exception))) {
23048
0
          UNDEF_RESULT();
23049
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23050
0
          HANDLE_EXCEPTION();
23051
0
        }
23052
0
      }
23053
10
      if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
23054
10
        if (array_ptr == array_ref) {
23055
10
          ZVAL_NEW_REF(array_ref, array_ref);
23056
10
          array_ptr = Z_REFVAL_P(array_ref);
23057
10
        }
23058
10
        Z_ADDREF_P(array_ref);
23059
10
        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
23060
10
      } else {
23061
0
        array_ptr = EX_VAR(opline->result.var);
23062
0
        ZVAL_COPY_VALUE(array_ptr, array_ref);
23063
0
      }
23064
10
      if (Z_OBJ_P(array_ptr)->properties
23065
10
       && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
23066
0
        if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
23067
0
          GC_DELREF(Z_OBJ_P(array_ptr)->properties);
23068
0
        }
23069
0
        Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
23070
0
      }
23071
23072
10
      properties = Z_OBJPROP_P(array_ptr);
23073
10
      if (zend_hash_num_elements(properties) == 0) {
23074
0
        Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
23075
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23076
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
23077
0
      }
23078
23079
10
      Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
23080
10
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23081
10
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23082
24
    } else {
23083
24
      bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
23084
24
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23085
24
      if (UNEXPECTED(EG(exception))) {
23086
0
        HANDLE_EXCEPTION();
23087
24
      } else if (is_empty) {
23088
0
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23089
24
      } else {
23090
24
        ZEND_VM_NEXT_OPCODE();
23091
24
      }
23092
24
    }
23093
34
  } else {
23094
9
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
23095
9
    ZVAL_UNDEF(EX_VAR(opline->result.var));
23096
9
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
23097
9
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23098
9
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
23099
9
  }
23100
81
}
23101
23102
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23103
260k
{
23104
260k
  USE_OPLINE
23105
260k
  zval *array;
23106
260k
  zval *value;
23107
260k
  uint32_t value_type;
23108
260k
  HashTable *fe_ht;
23109
260k
  HashPosition pos;
23110
23111
260k
  array = EX_VAR(opline->op1.var);
23112
260k
  if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) {
23113
3.66k
    ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23114
3.66k
  }
23115
257k
  fe_ht = Z_ARRVAL_P(array);
23116
257k
  pos = Z_FE_POS_P(array);
23117
257k
  if (HT_IS_PACKED(fe_ht)) {
23118
245k
    value = fe_ht->arPacked + pos;
23119
245k
    while (1) {
23120
245k
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23121
        /* reached end of iteration */
23122
8.18k
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23123
8.18k
        ZEND_VM_CONTINUE();
23124
8.18k
      }
23125
237k
      value_type = Z_TYPE_INFO_P(value);
23126
237k
      ZEND_ASSERT(value_type != IS_INDIRECT);
23127
237k
      if (EXPECTED(value_type != IS_UNDEF)) {
23128
237k
        break;
23129
237k
      }
23130
18
      pos++;
23131
18
      value++;
23132
18
    }
23133
237k
    Z_FE_POS_P(array) = pos + 1;
23134
237k
    if (RETURN_VALUE_USED(opline)) {
23135
266
      ZVAL_LONG(EX_VAR(opline->result.var), pos);
23136
266
    }
23137
237k
  } else {
23138
11.1k
    Bucket *p;
23139
23140
11.1k
    p = fe_ht->arData + pos;
23141
11.1k
    while (1) {
23142
11.1k
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23143
        /* reached end of iteration */
23144
867
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23145
867
        ZEND_VM_CONTINUE();
23146
867
      }
23147
10.3k
      pos++;
23148
10.3k
      value = &p->val;
23149
10.3k
      value_type = Z_TYPE_INFO_P(value);
23150
10.3k
      ZEND_ASSERT(value_type != IS_INDIRECT);
23151
10.3k
      if (EXPECTED(value_type != IS_UNDEF)) {
23152
10.2k
        break;
23153
10.2k
      }
23154
27
      p++;
23155
27
    }
23156
10.2k
    Z_FE_POS_P(array) = pos;
23157
10.2k
    if (RETURN_VALUE_USED(opline)) {
23158
993
      if (!p->key) {
23159
158
        ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23160
835
      } else {
23161
835
        ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23162
835
      }
23163
993
    }
23164
10.2k
  }
23165
248k
  if (EXPECTED(opline->op2_type == IS_CV)) {
23166
247k
    zval *variable_ptr = EX_VAR(opline->op2.var);
23167
247k
    SAVE_OPLINE();
23168
247k
    zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
23169
247k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23170
247k
  } else {
23171
882
    zval *res = EX_VAR(opline->op2.var);
23172
882
    zend_refcounted *gc = Z_COUNTED_P(value);
23173
23174
882
    ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
23175
882
    if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
23176
50
      GC_ADDREF(gc);
23177
50
    }
23178
882
    ZEND_VM_NEXT_OPCODE();
23179
882
  }
23180
248k
}
23181
23182
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23183
6.87k
{
23184
6.87k
  USE_OPLINE
23185
6.87k
  zval *array;
23186
6.87k
  zval *value;
23187
6.87k
  uint32_t value_type;
23188
6.87k
  HashTable *fe_ht;
23189
6.87k
  HashPosition pos;
23190
6.87k
  Bucket *p;
23191
23192
6.87k
  array = EX_VAR(opline->op1.var);
23193
6.87k
  SAVE_OPLINE();
23194
23195
6.87k
  ZVAL_DEREF(array);
23196
6.87k
  if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
23197
6.11k
    pos = zend_hash_iterator_pos_ex(Z_FE_ITER_P(EX_VAR(opline->op1.var)), array);
23198
6.11k
    fe_ht = Z_ARRVAL_P(array);
23199
6.11k
    if (HT_IS_PACKED(fe_ht)) {
23200
4.98k
      value = fe_ht->arPacked + pos;
23201
6.32k
      while (1) {
23202
6.32k
        if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23203
          /* reached end of iteration */
23204
714
          goto fe_fetch_w_exit;
23205
714
        }
23206
5.60k
        value_type = Z_TYPE_INFO_P(value);
23207
5.60k
        ZEND_ASSERT(value_type != IS_INDIRECT);
23208
5.60k
        if (EXPECTED(value_type != IS_UNDEF)) {
23209
4.26k
          break;
23210
4.26k
        }
23211
1.33k
        pos++;
23212
1.33k
        value++;
23213
1.33k
      }
23214
4.26k
      EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1;
23215
4.26k
      if (RETURN_VALUE_USED(opline)) {
23216
354
        ZVAL_LONG(EX_VAR(opline->result.var), pos);
23217
354
      }
23218
4.26k
    } else {
23219
1.13k
      p = fe_ht->arData + pos;
23220
1.15k
      while (1) {
23221
1.15k
        if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23222
          /* reached end of iteration */
23223
142
          goto fe_fetch_w_exit;
23224
142
        }
23225
1.00k
        pos++;
23226
1.00k
        value = &p->val;
23227
1.00k
        value_type = Z_TYPE_INFO_P(value);
23228
1.00k
        ZEND_ASSERT(value_type != IS_INDIRECT);
23229
1.00k
        if (EXPECTED(value_type != IS_UNDEF)) {
23230
990
          break;
23231
990
        }
23232
18
        p++;
23233
18
      }
23234
990
      EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
23235
990
      if (RETURN_VALUE_USED(opline)) {
23236
657
        if (!p->key) {
23237
583
          ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23238
583
        } else {
23239
74
          ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23240
74
        }
23241
657
      }
23242
990
    }
23243
6.11k
  } else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
23244
751
    zend_object_iterator *iter;
23245
23246
751
    if ((iter = zend_iterator_unwrap(array)) == NULL) {
23247
      /* plain object */
23248
23249
128
      fe_ht = Z_OBJPROP_P(array);
23250
128
      pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
23251
128
      p = fe_ht->arData + pos;
23252
138
      while (1) {
23253
138
        if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23254
          /* reached end of iteration */
23255
41
          goto fe_fetch_w_exit;
23256
41
        }
23257
97
        pos++;
23258
97
        value = &p->val;
23259
97
        value_type = Z_TYPE_INFO_P(value);
23260
97
        if (EXPECTED(value_type != IS_UNDEF)) {
23261
97
          if (UNEXPECTED(value_type == IS_INDIRECT)) {
23262
97
            value = Z_INDIRECT_P(value);
23263
97
            value_type = Z_TYPE_INFO_P(value);
23264
97
            if (EXPECTED(value_type != IS_UNDEF)
23265
97
             && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
23266
87
              if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
23267
77
                zend_property_info *prop_info =
23268
77
                  zend_get_property_info_for_slot(Z_OBJ_P(array), value);
23269
77
                if (prop_info) {
23270
77
                  if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) {
23271
5
                    zend_throw_error(NULL,
23272
5
                      "Cannot acquire reference to readonly property %s::$%s",
23273
5
                      ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(p->key));
23274
5
                    UNDEF_RESULT();
23275
5
                    HANDLE_EXCEPTION();
23276
5
                  }
23277
72
                  if (ZEND_TYPE_IS_SET(prop_info->type)) {
23278
67
                    ZVAL_NEW_REF(value, value);
23279
67
                    ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
23280
67
                    value_type = IS_REFERENCE_EX;
23281
67
                  }
23282
72
                }
23283
77
              }
23284
82
              break;
23285
87
            }
23286
97
          } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
23287
0
              || !p->key
23288
0
              || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
23289
0
            break;
23290
0
          }
23291
97
        }
23292
10
        p++;
23293
10
      }
23294
82
      EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
23295
82
      if (RETURN_VALUE_USED(opline)) {
23296
72
        if (UNEXPECTED(!p->key)) {
23297
0
          ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23298
72
        } else if (ZSTR_VAL(p->key)[0]) {
23299
67
          ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23300
67
        } else {
23301
5
          const char *class_name, *prop_name;
23302
5
          size_t prop_name_len;
23303
5
          zend_unmangle_property_name_ex(
23304
5
            p->key, &class_name, &prop_name, &prop_name_len);
23305
5
          ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
23306
5
        }
23307
72
      }
23308
623
    } else {
23309
623
      const zend_object_iterator_funcs *funcs = iter->funcs;
23310
623
      if (++iter->index > 0) {
23311
        /* This could cause an endless loop if index becomes zero again.
23312
         * In case that ever happens we need an additional flag. */
23313
436
        funcs->move_forward(iter);
23314
436
        if (UNEXPECTED(EG(exception) != NULL)) {
23315
2
          UNDEF_RESULT();
23316
2
          HANDLE_EXCEPTION();
23317
2
        }
23318
434
        if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
23319
          /* reached end of iteration */
23320
175
          if (UNEXPECTED(EG(exception) != NULL)) {
23321
5
            UNDEF_RESULT();
23322
5
            HANDLE_EXCEPTION();
23323
5
          }
23324
170
          goto fe_fetch_w_exit;
23325
175
        }
23326
434
      }
23327
446
      value = funcs->get_current_data(iter);
23328
446
      if (UNEXPECTED(EG(exception) != NULL)) {
23329
5
        UNDEF_RESULT();
23330
5
        HANDLE_EXCEPTION();
23331
5
      }
23332
441
      if (!value) {
23333
        /* failure in get_current_data */
23334
0
        goto fe_fetch_w_exit;
23335
0
      }
23336
441
      if (RETURN_VALUE_USED(opline)) {
23337
316
        if (funcs->get_current_key) {
23338
316
          funcs->get_current_key(iter, EX_VAR(opline->result.var));
23339
316
          if (UNEXPECTED(EG(exception) != NULL)) {
23340
0
            UNDEF_RESULT();
23341
0
            HANDLE_EXCEPTION();
23342
0
          }
23343
316
        } else {
23344
0
          ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
23345
0
        }
23346
316
      }
23347
441
      value_type = Z_TYPE_INFO_P(value);
23348
441
    }
23349
751
  } else {
23350
5
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array));
23351
5
    if (UNEXPECTED(EG(exception))) {
23352
0
      UNDEF_RESULT();
23353
0
      HANDLE_EXCEPTION();
23354
0
    }
23355
1.07k
fe_fetch_w_exit:
23356
1.07k
    ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23357
1.07k
    ZEND_VM_CONTINUE();
23358
1.07k
  }
23359
23360
5.78k
  if (EXPECTED((value_type & Z_TYPE_MASK) != IS_REFERENCE)) {
23361
4.45k
    zend_refcounted *gc = Z_COUNTED_P(value);
23362
4.45k
    zval *ref;
23363
4.45k
    ZVAL_NEW_EMPTY_REF(value);
23364
4.45k
    ref = Z_REFVAL_P(value);
23365
4.45k
    ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
23366
4.45k
  }
23367
5.78k
  if (EXPECTED(opline->op2_type == IS_CV)) {
23368
5.76k
    zval *variable_ptr = EX_VAR(opline->op2.var);
23369
5.76k
    if (EXPECTED(variable_ptr != value)) {
23370
5.76k
      zend_reference *ref;
23371
23372
5.76k
      ref = Z_REF_P(value);
23373
5.76k
      GC_ADDREF(ref);
23374
5.76k
      i_zval_ptr_dtor(variable_ptr);
23375
5.76k
      ZVAL_REF(variable_ptr, ref);
23376
5.76k
    }
23377
5.76k
  } else {
23378
20
    Z_ADDREF_P(value);
23379
20
    ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value));
23380
20
  }
23381
5.78k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23382
5.78k
}
23383
23384
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23385
7
{
23386
7
  USE_OPLINE
23387
7
  zval *value;
23388
7
  zend_reference *ref = NULL;
23389
7
  bool ret;
23390
23391
7
  SAVE_OPLINE();
23392
7
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23393
23394
7
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) {
23395
5
    if (IS_VAR == IS_VAR) {
23396
5
      ref = Z_REF_P(value);
23397
5
    }
23398
5
    value = Z_REFVAL_P(value);
23399
5
  }
23400
23401
7
  ret = i_zend_is_true(value);
23402
23403
7
  if (UNEXPECTED(EG(exception))) {
23404
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23405
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
23406
0
    HANDLE_EXCEPTION();
23407
0
  }
23408
23409
7
  if (ret) {
23410
5
    zval *result = EX_VAR(opline->result.var);
23411
23412
5
    ZVAL_COPY_VALUE(result, value);
23413
5
    if (IS_VAR == IS_CONST) {
23414
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
23415
5
    } else if (IS_VAR == IS_CV) {
23416
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
23417
5
    } else if (IS_VAR == IS_VAR && ref) {
23418
5
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23419
5
        efree_size(ref, sizeof(zend_reference));
23420
5
      } else if (Z_OPT_REFCOUNTED_P(result)) {
23421
0
        Z_ADDREF_P(result);
23422
0
      }
23423
5
    }
23424
5
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23425
5
  }
23426
23427
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23428
2
  ZEND_VM_NEXT_OPCODE();
23429
2
}
23430
23431
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23432
31
{
23433
31
  USE_OPLINE
23434
31
  zval *value;
23435
31
  zend_reference *ref = NULL;
23436
23437
31
  SAVE_OPLINE();
23438
31
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23439
23440
31
  if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
23441
26
    if (IS_VAR & IS_VAR) {
23442
26
      ref = Z_REF_P(value);
23443
26
    }
23444
26
    value = Z_REFVAL_P(value);
23445
26
  }
23446
23447
31
  if (Z_TYPE_P(value) > IS_NULL) {
23448
21
    zval *result = EX_VAR(opline->result.var);
23449
21
    ZVAL_COPY_VALUE(result, value);
23450
21
    if (IS_VAR == IS_CONST) {
23451
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
23452
21
    } else if (IS_VAR == IS_CV) {
23453
0
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
23454
21
    } else if ((IS_VAR & IS_VAR) && ref) {
23455
16
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23456
5
        efree_size(ref, sizeof(zend_reference));
23457
11
      } else if (Z_OPT_REFCOUNTED_P(result)) {
23458
0
        Z_ADDREF_P(result);
23459
0
      }
23460
16
    }
23461
21
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23462
21
  }
23463
23464
10
  if ((IS_VAR & IS_VAR) && ref) {
23465
10
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23466
0
      efree_size(ref, sizeof(zend_reference));
23467
0
    }
23468
10
  }
23469
10
  ZEND_VM_NEXT_OPCODE();
23470
10
}
23471
23472
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23473
139
{
23474
139
  USE_OPLINE
23475
139
  zval *val, *result;
23476
23477
139
  val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23478
23479
139
  if (Z_TYPE_P(val) > IS_NULL) {
23480
31
    do {
23481
31
      if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
23482
5
        val = Z_REFVAL_P(val);
23483
5
        if (Z_TYPE_P(val) <= IS_NULL) {
23484
5
          zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23485
5
          break;
23486
5
        }
23487
5
      }
23488
26
      ZEND_VM_NEXT_OPCODE();
23489
26
    } while (0);
23490
31
  }
23491
23492
113
  result = EX_VAR(opline->result.var);
23493
113
  uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
23494
113
  if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
23495
113
    ZVAL_NULL(result);
23496
113
    if (IS_VAR == IS_CV
23497
113
      && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
23498
113
      && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
23499
113
    ) {
23500
0
      SAVE_OPLINE();
23501
0
      ZVAL_UNDEFINED_OP1();
23502
0
      if (UNEXPECTED(EG(exception) != NULL)) {
23503
0
        HANDLE_EXCEPTION();
23504
0
      }
23505
0
    }
23506
113
  } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
23507
0
    ZVAL_FALSE(result);
23508
0
  } else {
23509
0
    ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
23510
0
    ZVAL_TRUE(result);
23511
0
  }
23512
23513
113
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23514
113
}
23515
23516
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23517
4.38k
{
23518
4.38k
  USE_OPLINE
23519
4.38k
  zval *value;
23520
4.38k
  zval *result = EX_VAR(opline->result.var);
23521
23522
4.38k
  value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23523
4.38k
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
23524
0
    SAVE_OPLINE();
23525
0
    ZVAL_UNDEFINED_OP1();
23526
0
    ZVAL_NULL(result);
23527
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23528
0
  }
23529
23530
4.38k
  if (IS_VAR == IS_CV) {
23531
0
    ZVAL_COPY_DEREF(result, value);
23532
4.38k
  } else if (IS_VAR == IS_VAR) {
23533
4.38k
    if (UNEXPECTED(Z_ISREF_P(value))) {
23534
87
      ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
23535
87
      if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
23536
5
        efree_size(Z_REF_P(value), sizeof(zend_reference));
23537
82
      } else if (Z_OPT_REFCOUNTED_P(result)) {
23538
0
        Z_ADDREF_P(result);
23539
0
      }
23540
4.29k
    } else {
23541
4.29k
      ZVAL_COPY_VALUE(result, value);
23542
4.29k
    }
23543
4.38k
  } else {
23544
0
    ZVAL_COPY_VALUE(result, value);
23545
0
    if (IS_VAR == IS_CONST) {
23546
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
23547
0
        Z_ADDREF_P(result);
23548
0
      }
23549
0
    }
23550
0
  }
23551
4.38k
  ZEND_VM_NEXT_OPCODE();
23552
4.38k
}
23553
23554
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23555
15.2k
{
23556
15.2k
  USE_OPLINE
23557
15.2k
  zval *varptr, *arg;
23558
23559
15.2k
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23560
15.2k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
23561
23562
15.2k
  if (IS_VAR == IS_CV) {
23563
0
    ZVAL_COPY(arg, varptr);
23564
15.2k
  } else /* if (IS_VAR == IS_VAR) */ {
23565
15.2k
    ZVAL_COPY_VALUE(arg, varptr);
23566
15.2k
  }
23567
23568
15.2k
  ZEND_VM_NEXT_OPCODE();
23569
15.2k
}
23570
23571
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23572
201
{
23573
201
  USE_OPLINE
23574
201
  zval *op1, *op2;
23575
201
  bool result;
23576
23577
201
  SAVE_OPLINE();
23578
201
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23579
201
  op2 = RT_CONSTANT(opline, opline->op2);
23580
201
  result = fast_is_identical_function(op1, op2);
23581
201
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23582
23583
201
  ZEND_VM_SMART_BRANCH(result, 1);
23584
201
}
23585
23586
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23587
0
{
23588
0
  USE_OPLINE
23589
0
  zval *op1, *op2;
23590
0
  bool result;
23591
23592
0
  SAVE_OPLINE();
23593
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23594
0
  op2 = RT_CONSTANT(opline, opline->op2);
23595
0
  result = fast_is_identical_function(op1, op2);
23596
23597
0
  ZEND_VM_SMART_BRANCH(result, 1);
23598
0
}
23599
23600
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23601
41
{
23602
41
  USE_OPLINE
23603
41
  zval *op1, *op2;
23604
41
  bool result;
23605
23606
41
  SAVE_OPLINE();
23607
41
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23608
41
  op2 = RT_CONSTANT(opline, opline->op2);
23609
41
  result = fast_is_not_identical_function(op1, op2);
23610
41
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23611
23612
41
  ZEND_VM_SMART_BRANCH(result, 1);
23613
41
}
23614
23615
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23616
41
{
23617
41
  USE_OPLINE
23618
41
  zval *object;
23619
41
  zval *property;
23620
41
  zval *value;
23621
41
  zval *zptr;
23622
41
  void *_cache_slot[3] = {0};
23623
41
  void **cache_slot;
23624
41
  zend_property_info *prop_info;
23625
41
  zend_object *zobj;
23626
41
  zend_string *name, *tmp_name;
23627
23628
41
  SAVE_OPLINE();
23629
41
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23630
41
  property = RT_CONSTANT(opline, opline->op2);
23631
23632
41
  do {
23633
41
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23634
23635
41
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23636
14
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23637
0
        object = Z_REFVAL_P(object);
23638
0
        goto assign_op_object;
23639
0
      }
23640
14
      if (IS_VAR == IS_CV
23641
14
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23642
0
        ZVAL_UNDEFINED_OP1();
23643
0
      }
23644
14
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23645
14
      break;
23646
14
    }
23647
23648
27
assign_op_object:
23649
    /* here we are sure we are dealing with an object */
23650
27
    zobj = Z_OBJ_P(object);
23651
27
    if (IS_CONST == IS_CONST) {
23652
27
      name = Z_STR_P(property);
23653
27
    } else {
23654
0
      name = zval_try_get_tmp_string(property, &tmp_name);
23655
0
      if (UNEXPECTED(!name)) {
23656
0
        UNDEF_RESULT();
23657
0
        break;
23658
0
      }
23659
0
    }
23660
27
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
23661
27
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23662
27
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23663
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23664
0
          ZVAL_NULL(EX_VAR(opline->result.var));
23665
0
        }
23666
27
      } else {
23667
27
        zend_reference *ref;
23668
23669
27
        do {
23670
27
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
23671
0
            ref = Z_REF_P(zptr);
23672
0
            zptr = Z_REFVAL_P(zptr);
23673
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23674
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23675
0
              break;
23676
0
            }
23677
0
          }
23678
23679
27
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23680
27
          if (prop_info) {
23681
            /* special case for typed properties */
23682
14
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
23683
14
          } else {
23684
13
            zend_binary_op(zptr, zptr, value OPLINE_CC);
23685
13
          }
23686
27
        } while (0);
23687
23688
27
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23689
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
23690
0
        }
23691
27
      }
23692
27
    } else {
23693
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
23694
0
    }
23695
27
    if (IS_CONST != IS_CONST) {
23696
0
      zend_tmp_string_release(tmp_name);
23697
0
    }
23698
27
  } while (0);
23699
23700
41
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23701
23702
41
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23703
  /* assign_obj has two opcodes! */
23704
41
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
23705
41
}
23706
23707
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
23708
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23709
293
{
23710
293
  USE_OPLINE
23711
293
  zval *var_ptr;
23712
293
  zval *value, *container, *dim;
23713
293
  HashTable *ht;
23714
23715
293
  SAVE_OPLINE();
23716
293
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23717
23718
293
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23719
186
assign_dim_op_array:
23720
186
    SEPARATE_ARRAY(container);
23721
186
    ht = Z_ARRVAL_P(container);
23722
293
assign_dim_op_new_array:
23723
293
    dim = RT_CONSTANT(opline, opline->op2);
23724
293
    if (IS_CONST == IS_UNUSED) {
23725
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
23726
0
      if (UNEXPECTED(!var_ptr)) {
23727
0
        zend_cannot_add_element();
23728
0
        goto assign_dim_op_ret_null;
23729
0
      }
23730
293
    } else {
23731
293
      if (IS_CONST == IS_CONST) {
23732
293
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
23733
293
      } else {
23734
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
23735
0
      }
23736
293
      if (UNEXPECTED(!var_ptr)) {
23737
0
        goto assign_dim_op_ret_null;
23738
0
      }
23739
293
    }
23740
23741
293
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23742
23743
293
    do {
23744
293
      if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
23745
0
        zend_reference *ref = Z_REF_P(var_ptr);
23746
0
        var_ptr = Z_REFVAL_P(var_ptr);
23747
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23748
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23749
0
          break;
23750
0
        }
23751
0
      }
23752
293
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23753
293
    } while (0);
23754
23755
293
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23756
57
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23757
57
    }
23758
293
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23759
293
  } else {
23760
107
    if (EXPECTED(Z_ISREF_P(container))) {
23761
0
      container = Z_REFVAL_P(container);
23762
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23763
0
        goto assign_dim_op_array;
23764
0
      }
23765
0
    }
23766
23767
107
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
23768
0
      zend_object *obj = Z_OBJ_P(container);
23769
23770
0
      dim = RT_CONSTANT(opline, opline->op2);
23771
0
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
23772
0
        dim++;
23773
0
      }
23774
0
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
23775
107
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
23776
107
      uint8_t old_type;
23777
23778
107
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
23779
0
        ZVAL_UNDEFINED_OP1();
23780
0
      }
23781
107
      ht = zend_new_array(8);
23782
107
      old_type = Z_TYPE_P(container);
23783
107
      ZVAL_ARR(container, ht);
23784
107
      if (UNEXPECTED(old_type == IS_FALSE)) {
23785
0
        GC_ADDREF(ht);
23786
0
        zend_false_to_array_deprecated();
23787
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
23788
0
          zend_array_destroy(ht);
23789
0
          goto assign_dim_op_ret_null;
23790
0
        }
23791
0
      }
23792
107
      goto assign_dim_op_new_array;
23793
107
    } else {
23794
0
      dim = RT_CONSTANT(opline, opline->op2);
23795
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
23796
0
assign_dim_op_ret_null:
23797
0
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23798
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23799
0
        ZVAL_NULL(EX_VAR(opline->result.var));
23800
0
      }
23801
0
    }
23802
107
  }
23803
23804
293
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23805
293
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
23806
293
}
23807
23808
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23809
38
{
23810
38
  USE_OPLINE
23811
38
  zval *var_ptr;
23812
38
  zval *value;
23813
23814
38
  SAVE_OPLINE();
23815
38
  value = RT_CONSTANT(opline, opline->op2);
23816
38
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23817
23818
38
  do {
23819
38
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
23820
0
      zend_reference *ref = Z_REF_P(var_ptr);
23821
0
      var_ptr = Z_REFVAL_P(var_ptr);
23822
0
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23823
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23824
0
        break;
23825
0
      }
23826
0
    }
23827
38
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23828
38
  } while (0);
23829
23830
38
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23831
0
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23832
0
  }
23833
23834
38
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23835
38
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23836
38
}
23837
23838
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23839
49
{
23840
49
  USE_OPLINE
23841
49
  zval *object;
23842
49
  zval *property;
23843
49
  zval *zptr;
23844
49
  void *_cache_slot[3] = {0};
23845
49
  void **cache_slot;
23846
49
  zend_property_info *prop_info;
23847
49
  zend_object *zobj;
23848
49
  zend_string *name, *tmp_name;
23849
23850
49
  SAVE_OPLINE();
23851
49
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23852
49
  property = RT_CONSTANT(opline, opline->op2);
23853
23854
49
  do {
23855
49
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23856
44
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23857
0
        object = Z_REFVAL_P(object);
23858
0
        goto pre_incdec_object;
23859
0
      }
23860
44
      if (IS_VAR == IS_CV
23861
44
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23862
0
        ZVAL_UNDEFINED_OP1();
23863
0
      }
23864
44
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23865
44
      break;
23866
44
    }
23867
23868
5
pre_incdec_object:
23869
    /* here we are sure we are dealing with an object */
23870
5
    zobj = Z_OBJ_P(object);
23871
5
    if (IS_CONST == IS_CONST) {
23872
5
      name = Z_STR_P(property);
23873
5
    } else {
23874
0
      name = zval_try_get_tmp_string(property, &tmp_name);
23875
0
      if (UNEXPECTED(!name)) {
23876
0
        UNDEF_RESULT();
23877
0
        break;
23878
0
      }
23879
0
    }
23880
5
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
23881
5
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23882
5
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23883
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23884
0
          ZVAL_NULL(EX_VAR(opline->result.var));
23885
0
        }
23886
5
      } else {
23887
5
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
23888
5
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23889
5
      }
23890
5
    } else {
23891
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23892
0
    }
23893
5
    if (IS_CONST != IS_CONST) {
23894
0
      zend_tmp_string_release(tmp_name);
23895
0
    }
23896
5
  } while (0);
23897
23898
49
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23899
49
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23900
49
}
23901
23902
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23903
0
{
23904
0
  USE_OPLINE
23905
0
  zval *object;
23906
0
  zval *property;
23907
0
  zval *zptr;
23908
0
  void *_cache_slot[3] = {0};
23909
0
  void **cache_slot;
23910
0
  zend_property_info *prop_info;
23911
0
  zend_object *zobj;
23912
0
  zend_string *name, *tmp_name;
23913
23914
0
  SAVE_OPLINE();
23915
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23916
0
  property = RT_CONSTANT(opline, opline->op2);
23917
23918
0
  do {
23919
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23920
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23921
0
        object = Z_REFVAL_P(object);
23922
0
        goto post_incdec_object;
23923
0
      }
23924
0
      if (IS_VAR == IS_CV
23925
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23926
0
        ZVAL_UNDEFINED_OP1();
23927
0
      }
23928
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23929
0
      break;
23930
0
    }
23931
23932
0
post_incdec_object:
23933
    /* here we are sure we are dealing with an object */
23934
0
    zobj = Z_OBJ_P(object);
23935
0
    if (IS_CONST == IS_CONST) {
23936
0
      name = Z_STR_P(property);
23937
0
    } else {
23938
0
      name = zval_try_get_tmp_string(property, &tmp_name);
23939
0
      if (UNEXPECTED(!name)) {
23940
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
23941
0
        break;
23942
0
      }
23943
0
    }
23944
0
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
23945
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23946
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23947
0
        ZVAL_NULL(EX_VAR(opline->result.var));
23948
0
      } else {
23949
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23950
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23951
0
      }
23952
0
    } else {
23953
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23954
0
    }
23955
0
    if (IS_CONST != IS_CONST) {
23956
0
      zend_tmp_string_release(tmp_name);
23957
0
    }
23958
0
  } while (0);
23959
23960
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23961
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23962
0
}
23963
23964
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23965
2.83k
{
23966
2.83k
  USE_OPLINE
23967
2.83k
  zval *container;
23968
23969
2.83k
  SAVE_OPLINE();
23970
2.83k
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23971
2.83k
  zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23972
23973
2.83k
  if (IS_VAR == IS_VAR) {
23974
2.83k
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23975
2.83k
  }
23976
2.83k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23977
2.83k
}
23978
23979
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23980
191
{
23981
191
  USE_OPLINE
23982
191
  zval *container;
23983
23984
191
  SAVE_OPLINE();
23985
191
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23986
191
  zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23987
23988
191
  if (IS_VAR == IS_VAR) {
23989
191
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23990
191
  }
23991
191
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23992
191
}
23993
23994
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23995
38
{
23996
#if 0
23997
  USE_OPLINE
23998
#endif
23999
24000
38
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
24001
21
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
24002
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24003
0
    }
24004
21
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24005
21
  } else {
24006
17
    if (IS_CONST == IS_UNUSED) {
24007
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24008
0
    }
24009
17
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24010
17
  }
24011
38
}
24012
24013
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24014
8
{
24015
8
  USE_OPLINE
24016
8
  zval *container;
24017
24018
8
  SAVE_OPLINE();
24019
8
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24020
8
  zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
24021
24022
8
  if (IS_VAR == IS_VAR) {
24023
8
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
24024
8
  }
24025
8
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24026
8
}
24027
24028
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24029
123
{
24030
123
  USE_OPLINE
24031
123
  zval *property, *container, *result;
24032
24033
123
  SAVE_OPLINE();
24034
24035
123
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24036
123
  property = RT_CONSTANT(opline, opline->op2);
24037
123
  result = EX_VAR(opline->result.var);
24038
123
  zend_fetch_property_address(
24039
123
    result, container, IS_VAR, property, IS_CONST,
24040
123
    ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
24041
123
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
24042
24043
123
  if (IS_VAR == IS_VAR) {
24044
123
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
24045
123
  }
24046
123
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24047
123
}
24048
24049
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24050
27
{
24051
27
  USE_OPLINE
24052
27
  zval *property, *container, *result;
24053
24054
27
  SAVE_OPLINE();
24055
27
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24056
27
  property = RT_CONSTANT(opline, opline->op2);
24057
27
  result = EX_VAR(opline->result.var);
24058
27
  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);
24059
24060
27
  if (IS_VAR == IS_VAR) {
24061
27
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
24062
27
  }
24063
27
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24064
27
}
24065
24066
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24067
27
{
24068
#if 0
24069
  USE_OPLINE
24070
#endif
24071
24072
27
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
24073
    /* Behave like FETCH_OBJ_W */
24074
12
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
24075
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24076
0
    }
24077
12
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24078
15
  } else {
24079
15
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
24080
15
  }
24081
27
}
24082
24083
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24084
39
{
24085
39
  USE_OPLINE
24086
39
  zval *container, *property, *result;
24087
24088
39
  SAVE_OPLINE();
24089
39
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24090
39
  property = RT_CONSTANT(opline, opline->op2);
24091
39
  result = EX_VAR(opline->result.var);
24092
39
  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);
24093
24094
39
  if (IS_VAR == IS_VAR) {
24095
39
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
24096
39
  }
24097
39
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24098
39
}
24099
24100
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24101
400
{
24102
400
  USE_OPLINE
24103
400
  zval *container, *dim;
24104
24105
400
  SAVE_OPLINE();
24106
400
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24107
400
  dim = RT_CONSTANT(opline, opline->op2);
24108
24109
400
  if (IS_VAR == IS_VAR
24110
400
    && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
24111
400
    && UNEXPECTED(!Z_ISREF_P(container))
24112
400
  ) {
24113
15
    zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
24114
15
    zend_fetch_dimension_address_LIST_r(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
24115
385
  } else {
24116
385
    zend_fetch_dimension_address_W(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
24117
385
  }
24118
24119
400
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24120
400
}
24121
24122
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24123
394
{
24124
394
  USE_OPLINE
24125
394
  zval *object, *value, tmp;
24126
394
  zend_object *zobj;
24127
394
  zend_string *name, *tmp_name;
24128
394
  zend_refcounted *garbage = NULL;
24129
24130
394
  SAVE_OPLINE();
24131
394
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24132
394
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
24133
24134
394
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24135
81
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24136
26
      object = Z_REFVAL_P(object);
24137
26
      goto assign_object;
24138
26
    }
24139
55
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24140
55
    value = &EG(uninitialized_zval);
24141
55
    goto free_and_exit_assign_obj;
24142
81
  }
24143
24144
339
assign_object:
24145
339
  zobj = Z_OBJ_P(object);
24146
339
  if (IS_CONST == IS_CONST) {
24147
339
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24148
90
      void **cache_slot = CACHE_ADDR(opline->extended_value);
24149
90
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24150
90
      zval *property_val;
24151
90
      zend_property_info *prop_info;
24152
24153
90
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24154
80
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24155
24156
80
assign_obj_simple:
24157
80
        property_val = OBJ_PROP(zobj, prop_offset);
24158
80
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
24159
73
          if (prop_info != NULL) {
24160
73
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24161
73
            goto free_and_exit_assign_obj;
24162
73
          } else {
24163
0
fast_assign_obj:
24164
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24165
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24166
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
24167
0
            }
24168
0
            goto exit_assign_obj;
24169
0
          }
24170
73
        }
24171
80
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24172
10
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24173
10
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24174
0
          zobj = zend_lazy_object_init(zobj);
24175
0
          if (!zobj) {
24176
0
            value = &EG(uninitialized_zval);
24177
0
            goto free_and_exit_assign_obj;
24178
0
          }
24179
0
        }
24180
10
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24181
10
          rebuild_object_properties_internal(zobj);
24182
10
        }
24183
10
        if (EXPECTED(zobj->properties != NULL)) {
24184
10
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24185
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24186
0
              GC_DELREF(zobj->properties);
24187
0
            }
24188
0
            zobj->properties = zend_array_dup(zobj->properties);
24189
0
          }
24190
10
          property_val = zend_hash_find_known_hash(zobj->properties, name);
24191
10
          if (property_val) {
24192
0
            goto fast_assign_obj;
24193
0
          }
24194
10
        }
24195
24196
10
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24197
10
          if (IS_CONST == IS_CONST) {
24198
10
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24199
0
              Z_ADDREF_P(value);
24200
0
            }
24201
10
          } else if (IS_CONST != IS_TMP_VAR) {
24202
0
            if (Z_ISREF_P(value)) {
24203
0
              if (IS_CONST == IS_VAR) {
24204
0
                zend_reference *ref = Z_REF_P(value);
24205
0
                if (GC_DELREF(ref) == 0) {
24206
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24207
0
                  efree_size(ref, sizeof(zend_reference));
24208
0
                  value = &tmp;
24209
0
                } else {
24210
0
                  value = Z_REFVAL_P(value);
24211
0
                  Z_TRY_ADDREF_P(value);
24212
0
                }
24213
0
              } else {
24214
0
                value = Z_REFVAL_P(value);
24215
0
                Z_TRY_ADDREF_P(value);
24216
0
              }
24217
0
            } else if (IS_CONST == IS_CV) {
24218
0
              Z_TRY_ADDREF_P(value);
24219
0
            }
24220
0
          }
24221
10
          zend_hash_add_new(zobj->properties, name, value);
24222
10
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24223
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
24224
0
          }
24225
10
          goto exit_assign_obj;
24226
10
        }
24227
10
      } else {
24228
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24229
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24230
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
24231
0
          prop_offset = prop_info->offset;
24232
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24233
0
            prop_info = NULL;
24234
0
          }
24235
0
          goto assign_obj_simple;
24236
0
        }
24237
        /* Fall through to write_property for hooks. */
24238
0
      }
24239
90
    }
24240
256
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24241
256
  } else {
24242
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24243
0
    if (UNEXPECTED(!name)) {
24244
24245
0
      UNDEF_RESULT();
24246
0
      goto exit_assign_obj;
24247
0
    }
24248
0
  }
24249
24250
256
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24251
0
    ZVAL_DEREF(value);
24252
0
  }
24253
24254
256
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24255
24256
256
  if (IS_CONST != IS_CONST) {
24257
0
    zend_tmp_string_release(tmp_name);
24258
0
  }
24259
24260
384
free_and_exit_assign_obj:
24261
384
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24262
50
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24263
50
  }
24264
24265
394
exit_assign_obj:
24266
394
  if (garbage) {
24267
0
    GC_DTOR_NO_REF(garbage);
24268
0
  }
24269
24270
394
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24271
  /* assign_obj has two opcodes! */
24272
394
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24273
394
}
24274
24275
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24276
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24277
261
{
24278
261
  USE_OPLINE
24279
261
  zval *object, *value, tmp;
24280
261
  zend_object *zobj;
24281
261
  zend_string *name, *tmp_name;
24282
261
  zend_refcounted *garbage = NULL;
24283
24284
261
  SAVE_OPLINE();
24285
261
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24286
261
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24287
24288
261
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24289
10
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24290
0
      object = Z_REFVAL_P(object);
24291
0
      goto assign_object;
24292
0
    }
24293
10
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24294
10
    value = &EG(uninitialized_zval);
24295
10
    goto free_and_exit_assign_obj;
24296
10
  }
24297
24298
251
assign_object:
24299
251
  zobj = Z_OBJ_P(object);
24300
251
  if (IS_CONST == IS_CONST) {
24301
251
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24302
117
      void **cache_slot = CACHE_ADDR(opline->extended_value);
24303
117
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24304
117
      zval *property_val;
24305
117
      zend_property_info *prop_info;
24306
24307
117
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24308
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24309
24310
0
assign_obj_simple:
24311
0
        property_val = OBJ_PROP(zobj, prop_offset);
24312
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
24313
0
          if (prop_info != NULL) {
24314
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24315
0
            goto free_and_exit_assign_obj;
24316
0
          } else {
24317
0
fast_assign_obj:
24318
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24319
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24320
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
24321
0
            }
24322
0
            goto exit_assign_obj;
24323
0
          }
24324
0
        }
24325
117
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24326
117
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24327
117
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24328
0
          zobj = zend_lazy_object_init(zobj);
24329
0
          if (!zobj) {
24330
0
            value = &EG(uninitialized_zval);
24331
0
            goto free_and_exit_assign_obj;
24332
0
          }
24333
0
        }
24334
117
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24335
114
          rebuild_object_properties_internal(zobj);
24336
114
        }
24337
117
        if (EXPECTED(zobj->properties != NULL)) {
24338
114
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24339
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24340
0
              GC_DELREF(zobj->properties);
24341
0
            }
24342
0
            zobj->properties = zend_array_dup(zobj->properties);
24343
0
          }
24344
114
          property_val = zend_hash_find_known_hash(zobj->properties, name);
24345
114
          if (property_val) {
24346
0
            goto fast_assign_obj;
24347
0
          }
24348
114
        }
24349
24350
117
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24351
114
          if (IS_TMP_VAR == IS_CONST) {
24352
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24353
0
              Z_ADDREF_P(value);
24354
0
            }
24355
114
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
24356
0
            if (Z_ISREF_P(value)) {
24357
0
              if (IS_TMP_VAR == IS_VAR) {
24358
0
                zend_reference *ref = Z_REF_P(value);
24359
0
                if (GC_DELREF(ref) == 0) {
24360
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24361
0
                  efree_size(ref, sizeof(zend_reference));
24362
0
                  value = &tmp;
24363
0
                } else {
24364
0
                  value = Z_REFVAL_P(value);
24365
0
                  Z_TRY_ADDREF_P(value);
24366
0
                }
24367
0
              } else {
24368
0
                value = Z_REFVAL_P(value);
24369
0
                Z_TRY_ADDREF_P(value);
24370
0
              }
24371
0
            } else if (IS_TMP_VAR == IS_CV) {
24372
0
              Z_TRY_ADDREF_P(value);
24373
0
            }
24374
0
          }
24375
114
          zend_hash_add_new(zobj->properties, name, value);
24376
114
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24377
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
24378
0
          }
24379
114
          goto exit_assign_obj;
24380
114
        }
24381
117
      } else {
24382
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24383
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24384
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
24385
0
          prop_offset = prop_info->offset;
24386
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24387
0
            prop_info = NULL;
24388
0
          }
24389
0
          goto assign_obj_simple;
24390
0
        }
24391
        /* Fall through to write_property for hooks. */
24392
0
      }
24393
117
    }
24394
137
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24395
137
  } else {
24396
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24397
0
    if (UNEXPECTED(!name)) {
24398
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24399
0
      UNDEF_RESULT();
24400
0
      goto exit_assign_obj;
24401
0
    }
24402
0
  }
24403
24404
137
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24405
0
    ZVAL_DEREF(value);
24406
0
  }
24407
24408
137
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24409
24410
137
  if (IS_CONST != IS_CONST) {
24411
0
    zend_tmp_string_release(tmp_name);
24412
0
  }
24413
24414
147
free_and_exit_assign_obj:
24415
147
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24416
8
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24417
8
  }
24418
147
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24419
261
exit_assign_obj:
24420
261
  if (garbage) {
24421
0
    GC_DTOR_NO_REF(garbage);
24422
0
  }
24423
24424
261
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24425
  /* assign_obj has two opcodes! */
24426
261
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24427
261
}
24428
24429
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24430
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24431
50
{
24432
50
  USE_OPLINE
24433
50
  zval *object, *value, tmp;
24434
50
  zend_object *zobj;
24435
50
  zend_string *name, *tmp_name;
24436
50
  zend_refcounted *garbage = NULL;
24437
24438
50
  SAVE_OPLINE();
24439
50
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24440
50
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24441
24442
50
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24443
15
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24444
10
      object = Z_REFVAL_P(object);
24445
10
      goto assign_object;
24446
10
    }
24447
5
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24448
5
    value = &EG(uninitialized_zval);
24449
5
    goto free_and_exit_assign_obj;
24450
15
  }
24451
24452
45
assign_object:
24453
45
  zobj = Z_OBJ_P(object);
24454
45
  if (IS_CONST == IS_CONST) {
24455
45
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24456
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
24457
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24458
0
      zval *property_val;
24459
0
      zend_property_info *prop_info;
24460
24461
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24462
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24463
24464
0
assign_obj_simple:
24465
0
        property_val = OBJ_PROP(zobj, prop_offset);
24466
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
24467
0
          if (prop_info != NULL) {
24468
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24469
0
            goto free_and_exit_assign_obj;
24470
0
          } else {
24471
0
fast_assign_obj:
24472
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
24473
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24474
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
24475
0
            }
24476
0
            goto exit_assign_obj;
24477
0
          }
24478
0
        }
24479
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24480
0
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24481
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24482
0
          zobj = zend_lazy_object_init(zobj);
24483
0
          if (!zobj) {
24484
0
            value = &EG(uninitialized_zval);
24485
0
            goto free_and_exit_assign_obj;
24486
0
          }
24487
0
        }
24488
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24489
0
          rebuild_object_properties_internal(zobj);
24490
0
        }
24491
0
        if (EXPECTED(zobj->properties != NULL)) {
24492
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24493
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24494
0
              GC_DELREF(zobj->properties);
24495
0
            }
24496
0
            zobj->properties = zend_array_dup(zobj->properties);
24497
0
          }
24498
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
24499
0
          if (property_val) {
24500
0
            goto fast_assign_obj;
24501
0
          }
24502
0
        }
24503
24504
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24505
0
          if (IS_VAR == IS_CONST) {
24506
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24507
0
              Z_ADDREF_P(value);
24508
0
            }
24509
0
          } else if (IS_VAR != IS_TMP_VAR) {
24510
0
            if (Z_ISREF_P(value)) {
24511
0
              if (IS_VAR == IS_VAR) {
24512
0
                zend_reference *ref = Z_REF_P(value);
24513
0
                if (GC_DELREF(ref) == 0) {
24514
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24515
0
                  efree_size(ref, sizeof(zend_reference));
24516
0
                  value = &tmp;
24517
0
                } else {
24518
0
                  value = Z_REFVAL_P(value);
24519
0
                  Z_TRY_ADDREF_P(value);
24520
0
                }
24521
0
              } else {
24522
0
                value = Z_REFVAL_P(value);
24523
0
                Z_TRY_ADDREF_P(value);
24524
0
              }
24525
0
            } else if (IS_VAR == IS_CV) {
24526
0
              Z_TRY_ADDREF_P(value);
24527
0
            }
24528
0
          }
24529
0
          zend_hash_add_new(zobj->properties, name, value);
24530
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24531
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
24532
0
          }
24533
0
          goto exit_assign_obj;
24534
0
        }
24535
0
      } else {
24536
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24537
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24538
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
24539
0
          prop_offset = prop_info->offset;
24540
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24541
0
            prop_info = NULL;
24542
0
          }
24543
0
          goto assign_obj_simple;
24544
0
        }
24545
        /* Fall through to write_property for hooks. */
24546
0
      }
24547
0
    }
24548
45
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24549
45
  } else {
24550
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24551
0
    if (UNEXPECTED(!name)) {
24552
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24553
0
      UNDEF_RESULT();
24554
0
      goto exit_assign_obj;
24555
0
    }
24556
0
  }
24557
24558
45
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24559
45
    ZVAL_DEREF(value);
24560
45
  }
24561
24562
45
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24563
24564
45
  if (IS_CONST != IS_CONST) {
24565
0
    zend_tmp_string_release(tmp_name);
24566
0
  }
24567
24568
50
free_and_exit_assign_obj:
24569
50
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24570
15
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24571
15
  }
24572
50
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24573
50
exit_assign_obj:
24574
50
  if (garbage) {
24575
0
    GC_DTOR_NO_REF(garbage);
24576
0
  }
24577
24578
50
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24579
  /* assign_obj has two opcodes! */
24580
50
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24581
50
}
24582
24583
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24584
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24585
169
{
24586
169
  USE_OPLINE
24587
169
  zval *object, *value, tmp;
24588
169
  zend_object *zobj;
24589
169
  zend_string *name, *tmp_name;
24590
169
  zend_refcounted *garbage = NULL;
24591
24592
169
  SAVE_OPLINE();
24593
169
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24594
169
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
24595
24596
169
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24597
3
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24598
0
      object = Z_REFVAL_P(object);
24599
0
      goto assign_object;
24600
0
    }
24601
3
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24602
3
    value = &EG(uninitialized_zval);
24603
3
    goto free_and_exit_assign_obj;
24604
3
  }
24605
24606
166
assign_object:
24607
166
  zobj = Z_OBJ_P(object);
24608
166
  if (IS_CONST == IS_CONST) {
24609
166
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24610
124
      void **cache_slot = CACHE_ADDR(opline->extended_value);
24611
124
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24612
124
      zval *property_val;
24613
124
      zend_property_info *prop_info;
24614
24615
124
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24616
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24617
24618
0
assign_obj_simple:
24619
0
        property_val = OBJ_PROP(zobj, prop_offset);
24620
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
24621
0
          if (prop_info != NULL) {
24622
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24623
0
            goto free_and_exit_assign_obj;
24624
0
          } else {
24625
0
fast_assign_obj:
24626
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
24627
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24628
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
24629
0
            }
24630
0
            goto exit_assign_obj;
24631
0
          }
24632
0
        }
24633
124
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24634
124
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24635
124
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24636
0
          zobj = zend_lazy_object_init(zobj);
24637
0
          if (!zobj) {
24638
0
            value = &EG(uninitialized_zval);
24639
0
            goto free_and_exit_assign_obj;
24640
0
          }
24641
0
        }
24642
124
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24643
124
          rebuild_object_properties_internal(zobj);
24644
124
        }
24645
124
        if (EXPECTED(zobj->properties != NULL)) {
24646
124
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24647
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24648
0
              GC_DELREF(zobj->properties);
24649
0
            }
24650
0
            zobj->properties = zend_array_dup(zobj->properties);
24651
0
          }
24652
124
          property_val = zend_hash_find_known_hash(zobj->properties, name);
24653
124
          if (property_val) {
24654
0
            goto fast_assign_obj;
24655
0
          }
24656
124
        }
24657
24658
124
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24659
124
          if (IS_CV == IS_CONST) {
24660
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24661
0
              Z_ADDREF_P(value);
24662
0
            }
24663
124
          } else if (IS_CV != IS_TMP_VAR) {
24664
124
            if (Z_ISREF_P(value)) {
24665
0
              if (IS_CV == IS_VAR) {
24666
0
                zend_reference *ref = Z_REF_P(value);
24667
0
                if (GC_DELREF(ref) == 0) {
24668
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24669
0
                  efree_size(ref, sizeof(zend_reference));
24670
0
                  value = &tmp;
24671
0
                } else {
24672
0
                  value = Z_REFVAL_P(value);
24673
0
                  Z_TRY_ADDREF_P(value);
24674
0
                }
24675
0
              } else {
24676
0
                value = Z_REFVAL_P(value);
24677
0
                Z_TRY_ADDREF_P(value);
24678
0
              }
24679
124
            } else if (IS_CV == IS_CV) {
24680
124
              Z_TRY_ADDREF_P(value);
24681
124
            }
24682
124
          }
24683
124
          zend_hash_add_new(zobj->properties, name, value);
24684
124
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24685
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
24686
0
          }
24687
124
          goto exit_assign_obj;
24688
124
        }
24689
124
      } else {
24690
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24691
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24692
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
24693
0
          prop_offset = prop_info->offset;
24694
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24695
0
            prop_info = NULL;
24696
0
          }
24697
0
          goto assign_obj_simple;
24698
0
        }
24699
        /* Fall through to write_property for hooks. */
24700
0
      }
24701
124
    }
24702
42
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24703
42
  } else {
24704
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24705
0
    if (UNEXPECTED(!name)) {
24706
24707
0
      UNDEF_RESULT();
24708
0
      goto exit_assign_obj;
24709
0
    }
24710
0
  }
24711
24712
42
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24713
42
    ZVAL_DEREF(value);
24714
42
  }
24715
24716
42
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24717
24718
42
  if (IS_CONST != IS_CONST) {
24719
0
    zend_tmp_string_release(tmp_name);
24720
0
  }
24721
24722
45
free_and_exit_assign_obj:
24723
45
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24724
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24725
0
  }
24726
24727
169
exit_assign_obj:
24728
169
  if (garbage) {
24729
0
    GC_DTOR_NO_REF(garbage);
24730
0
  }
24731
24732
169
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24733
  /* assign_obj has two opcodes! */
24734
169
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24735
169
}
24736
24737
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24738
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24739
831
{
24740
831
  USE_OPLINE
24741
831
  zval *object_ptr, *orig_object_ptr;
24742
831
  zval *value;
24743
831
  zval *variable_ptr;
24744
831
  zval *dim;
24745
831
  zend_refcounted *garbage = NULL;
24746
24747
831
  SAVE_OPLINE();
24748
831
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24749
24750
831
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24751
795
try_assign_dim_array:
24752
795
    SEPARATE_ARRAY(object_ptr);
24753
795
    if (IS_CONST == IS_UNUSED) {
24754
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
24755
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24756
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
24757
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24758
0
          GC_ADDREF(ht);
24759
0
        }
24760
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24761
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24762
0
          zend_array_destroy(ht);
24763
0
          goto assign_dim_error;
24764
0
        }
24765
0
      }
24766
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24767
0
        ZVAL_DEREF(value);
24768
0
      }
24769
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24770
0
      if (UNEXPECTED(value == NULL)) {
24771
0
        zend_cannot_add_element();
24772
0
        goto assign_dim_error;
24773
0
      } else if (IS_CONST == IS_CV) {
24774
0
        if (Z_REFCOUNTED_P(value)) {
24775
0
          Z_ADDREF_P(value);
24776
0
        }
24777
0
      } else if (IS_CONST == IS_VAR) {
24778
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
24779
0
        if (Z_ISREF_P(free_op_data)) {
24780
0
          if (Z_REFCOUNTED_P(value)) {
24781
0
            Z_ADDREF_P(value);
24782
0
          }
24783
0
          zval_ptr_dtor_nogc(free_op_data);
24784
0
        }
24785
0
      } else if (IS_CONST == IS_CONST) {
24786
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24787
0
          Z_ADDREF_P(value);
24788
0
        }
24789
0
      }
24790
795
    } else {
24791
795
      dim = RT_CONSTANT(opline, opline->op2);
24792
795
      if (IS_CONST == IS_CONST) {
24793
795
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24794
795
      } else {
24795
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24796
0
      }
24797
795
      if (UNEXPECTED(variable_ptr == NULL)) {
24798
0
        goto assign_dim_error;
24799
0
      }
24800
795
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
24801
795
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24802
795
    }
24803
795
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24804
179
      ZVAL_COPY(EX_VAR(opline->result.var), value);
24805
179
    }
24806
795
    if (garbage) {
24807
2
      GC_DTOR_NO_REF(garbage);
24808
2
    }
24809
795
  } else {
24810
434
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
24811
94
      object_ptr = Z_REFVAL_P(object_ptr);
24812
94
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24813
47
        goto try_assign_dim_array;
24814
47
      }
24815
94
    }
24816
387
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24817
28
      zend_object *obj = Z_OBJ_P(object_ptr);
24818
24819
28
      GC_ADDREF(obj);
24820
28
      dim = RT_CONSTANT(opline, opline->op2);
24821
28
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24822
0
        dim = ZVAL_UNDEFINED_OP2();
24823
28
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24824
0
        dim++;
24825
0
      }
24826
24827
28
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
24828
28
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24829
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24830
28
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
24831
0
        ZVAL_DEREF(value);
24832
0
      }
24833
24834
28
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24835
24836
28
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24837
0
        zend_objects_store_del(obj);
24838
0
      }
24839
359
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24840
6
      if (IS_CONST == IS_UNUSED) {
24841
0
        zend_use_new_element_for_string();
24842
24843
0
        UNDEF_RESULT();
24844
6
      } else {
24845
6
        dim = RT_CONSTANT(opline, opline->op2);
24846
6
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
24847
6
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24848
24849
6
      }
24850
353
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24851
351
      if (Z_ISREF_P(orig_object_ptr)
24852
351
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24853
351
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24854
0
        dim = RT_CONSTANT(opline, opline->op2);
24855
24856
0
        UNDEF_RESULT();
24857
351
      } else {
24858
351
        HashTable *ht = zend_new_array(8);
24859
351
        uint8_t old_type = Z_TYPE_P(object_ptr);
24860
24861
351
        ZVAL_ARR(object_ptr, ht);
24862
351
        if (UNEXPECTED(old_type == IS_FALSE)) {
24863
0
          GC_ADDREF(ht);
24864
0
          zend_false_to_array_deprecated();
24865
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24866
0
            zend_array_destroy(ht);
24867
0
            goto assign_dim_error;
24868
0
          }
24869
0
        }
24870
351
        goto try_assign_dim_array;
24871
351
      }
24872
351
    } else {
24873
2
      zend_use_scalar_as_array();
24874
2
      dim = RT_CONSTANT(opline, opline->op2);
24875
2
assign_dim_error:
24876
24877
2
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24878
0
        ZVAL_NULL(EX_VAR(opline->result.var));
24879
0
      }
24880
2
    }
24881
387
  }
24882
831
  if (IS_CONST != IS_UNUSED) {
24883
24884
831
  }
24885
831
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24886
  /* assign_dim has two opcodes! */
24887
831
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
24888
831
}
24889
24890
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24891
134
{
24892
134
  USE_OPLINE
24893
134
  zval *object_ptr, *orig_object_ptr;
24894
134
  zval *value;
24895
134
  zval *variable_ptr;
24896
134
  zval *dim;
24897
134
  zend_refcounted *garbage = NULL;
24898
24899
134
  SAVE_OPLINE();
24900
134
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24901
24902
134
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24903
134
try_assign_dim_array:
24904
134
    SEPARATE_ARRAY(object_ptr);
24905
134
    if (IS_CONST == IS_UNUSED) {
24906
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24907
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24908
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
24909
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24910
0
          GC_ADDREF(ht);
24911
0
        }
24912
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24913
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24914
0
          zend_array_destroy(ht);
24915
0
          goto assign_dim_error;
24916
0
        }
24917
0
      }
24918
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24919
0
        ZVAL_DEREF(value);
24920
0
      }
24921
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24922
0
      if (UNEXPECTED(value == NULL)) {
24923
0
        zend_cannot_add_element();
24924
0
        goto assign_dim_error;
24925
0
      } else if (IS_TMP_VAR == IS_CV) {
24926
0
        if (Z_REFCOUNTED_P(value)) {
24927
0
          Z_ADDREF_P(value);
24928
0
        }
24929
0
      } else if (IS_TMP_VAR == IS_VAR) {
24930
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
24931
0
        if (Z_ISREF_P(free_op_data)) {
24932
0
          if (Z_REFCOUNTED_P(value)) {
24933
0
            Z_ADDREF_P(value);
24934
0
          }
24935
0
          zval_ptr_dtor_nogc(free_op_data);
24936
0
        }
24937
0
      } else if (IS_TMP_VAR == IS_CONST) {
24938
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24939
0
          Z_ADDREF_P(value);
24940
0
        }
24941
0
      }
24942
134
    } else {
24943
134
      dim = RT_CONSTANT(opline, opline->op2);
24944
134
      if (IS_CONST == IS_CONST) {
24945
134
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24946
134
      } else {
24947
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24948
0
      }
24949
134
      if (UNEXPECTED(variable_ptr == NULL)) {
24950
0
        goto assign_dim_error;
24951
0
      }
24952
134
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24953
134
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24954
134
    }
24955
134
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24956
11
      ZVAL_COPY(EX_VAR(opline->result.var), value);
24957
11
    }
24958
134
    if (garbage) {
24959
72
      GC_DTOR_NO_REF(garbage);
24960
72
    }
24961
134
  } else {
24962
34
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
24963
11
      object_ptr = Z_REFVAL_P(object_ptr);
24964
11
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24965
3
        goto try_assign_dim_array;
24966
3
      }
24967
11
    }
24968
31
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24969
0
      zend_object *obj = Z_OBJ_P(object_ptr);
24970
24971
0
      GC_ADDREF(obj);
24972
0
      dim = RT_CONSTANT(opline, opline->op2);
24973
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24974
0
        dim = ZVAL_UNDEFINED_OP2();
24975
0
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24976
0
        dim++;
24977
0
      }
24978
24979
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24980
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24981
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24982
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
24983
0
        ZVAL_DEREF(value);
24984
0
      }
24985
24986
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24987
24988
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24989
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24990
0
        zend_objects_store_del(obj);
24991
0
      }
24992
31
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24993
0
      if (IS_CONST == IS_UNUSED) {
24994
0
        zend_use_new_element_for_string();
24995
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24996
0
        UNDEF_RESULT();
24997
0
      } else {
24998
0
        dim = RT_CONSTANT(opline, opline->op2);
24999
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
25000
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25001
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25002
0
      }
25003
31
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25004
31
      if (Z_ISREF_P(orig_object_ptr)
25005
31
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25006
31
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25007
0
        dim = RT_CONSTANT(opline, opline->op2);
25008
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25009
0
        UNDEF_RESULT();
25010
31
      } else {
25011
31
        HashTable *ht = zend_new_array(8);
25012
31
        uint8_t old_type = Z_TYPE_P(object_ptr);
25013
25014
31
        ZVAL_ARR(object_ptr, ht);
25015
31
        if (UNEXPECTED(old_type == IS_FALSE)) {
25016
0
          GC_ADDREF(ht);
25017
0
          zend_false_to_array_deprecated();
25018
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25019
0
            zend_array_destroy(ht);
25020
0
            goto assign_dim_error;
25021
0
          }
25022
0
        }
25023
31
        goto try_assign_dim_array;
25024
31
      }
25025
31
    } else {
25026
0
      zend_use_scalar_as_array();
25027
0
      dim = RT_CONSTANT(opline, opline->op2);
25028
0
assign_dim_error:
25029
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25030
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25031
0
        ZVAL_NULL(EX_VAR(opline->result.var));
25032
0
      }
25033
0
    }
25034
31
  }
25035
134
  if (IS_CONST != IS_UNUSED) {
25036
25037
134
  }
25038
134
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25039
  /* assign_dim has two opcodes! */
25040
134
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25041
134
}
25042
25043
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25044
216
{
25045
216
  USE_OPLINE
25046
216
  zval *object_ptr, *orig_object_ptr;
25047
216
  zval *value;
25048
216
  zval *variable_ptr;
25049
216
  zval *dim;
25050
216
  zend_refcounted *garbage = NULL;
25051
25052
216
  SAVE_OPLINE();
25053
216
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25054
25055
216
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25056
206
try_assign_dim_array:
25057
206
    SEPARATE_ARRAY(object_ptr);
25058
206
    if (IS_CONST == IS_UNUSED) {
25059
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25060
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
25061
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
25062
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
25063
0
          GC_ADDREF(ht);
25064
0
        }
25065
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25066
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
25067
0
          zend_array_destroy(ht);
25068
0
          goto assign_dim_error;
25069
0
        }
25070
0
      }
25071
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
25072
0
        ZVAL_DEREF(value);
25073
0
      }
25074
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
25075
0
      if (UNEXPECTED(value == NULL)) {
25076
0
        zend_cannot_add_element();
25077
0
        goto assign_dim_error;
25078
0
      } else if (IS_VAR == IS_CV) {
25079
0
        if (Z_REFCOUNTED_P(value)) {
25080
0
          Z_ADDREF_P(value);
25081
0
        }
25082
0
      } else if (IS_VAR == IS_VAR) {
25083
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
25084
0
        if (Z_ISREF_P(free_op_data)) {
25085
0
          if (Z_REFCOUNTED_P(value)) {
25086
0
            Z_ADDREF_P(value);
25087
0
          }
25088
0
          zval_ptr_dtor_nogc(free_op_data);
25089
0
        }
25090
0
      } else if (IS_VAR == IS_CONST) {
25091
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
25092
0
          Z_ADDREF_P(value);
25093
0
        }
25094
0
      }
25095
206
    } else {
25096
206
      dim = RT_CONSTANT(opline, opline->op2);
25097
206
      if (IS_CONST == IS_CONST) {
25098
206
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25099
206
      } else {
25100
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25101
0
      }
25102
206
      if (UNEXPECTED(variable_ptr == NULL)) {
25103
0
        goto assign_dim_error;
25104
0
      }
25105
206
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25106
206
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
25107
206
    }
25108
206
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25109
144
      ZVAL_COPY(EX_VAR(opline->result.var), value);
25110
144
    }
25111
206
    if (garbage) {
25112
88
      GC_DTOR_NO_REF(garbage);
25113
88
    }
25114
206
  } else {
25115
93
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
25116
5
      object_ptr = Z_REFVAL_P(object_ptr);
25117
5
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25118
0
        goto try_assign_dim_array;
25119
0
      }
25120
5
    }
25121
93
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
25122
10
      zend_object *obj = Z_OBJ_P(object_ptr);
25123
25124
10
      GC_ADDREF(obj);
25125
10
      dim = RT_CONSTANT(opline, opline->op2);
25126
10
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
25127
0
        dim = ZVAL_UNDEFINED_OP2();
25128
10
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
25129
0
        dim++;
25130
0
      }
25131
25132
10
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25133
10
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
25134
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25135
10
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
25136
10
        ZVAL_DEREF(value);
25137
10
      }
25138
25139
10
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
25140
25141
10
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25142
10
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
25143
0
        zend_objects_store_del(obj);
25144
0
      }
25145
83
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
25146
0
      if (IS_CONST == IS_UNUSED) {
25147
0
        zend_use_new_element_for_string();
25148
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25149
0
        UNDEF_RESULT();
25150
0
      } else {
25151
0
        dim = RT_CONSTANT(opline, opline->op2);
25152
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25153
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25154
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25155
0
      }
25156
83
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25157
83
      if (Z_ISREF_P(orig_object_ptr)
25158
83
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25159
83
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25160
0
        dim = RT_CONSTANT(opline, opline->op2);
25161
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25162
0
        UNDEF_RESULT();
25163
83
      } else {
25164
83
        HashTable *ht = zend_new_array(8);
25165
83
        uint8_t old_type = Z_TYPE_P(object_ptr);
25166
25167
83
        ZVAL_ARR(object_ptr, ht);
25168
83
        if (UNEXPECTED(old_type == IS_FALSE)) {
25169
2
          GC_ADDREF(ht);
25170
2
          zend_false_to_array_deprecated();
25171
2
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25172
0
            zend_array_destroy(ht);
25173
0
            goto assign_dim_error;
25174
0
          }
25175
2
        }
25176
83
        goto try_assign_dim_array;
25177
83
      }
25178
83
    } else {
25179
0
      zend_use_scalar_as_array();
25180
0
      dim = RT_CONSTANT(opline, opline->op2);
25181
0
assign_dim_error:
25182
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25183
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25184
0
        ZVAL_NULL(EX_VAR(opline->result.var));
25185
0
      }
25186
0
    }
25187
93
  }
25188
216
  if (IS_CONST != IS_UNUSED) {
25189
25190
216
  }
25191
216
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25192
  /* assign_dim has two opcodes! */
25193
216
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25194
216
}
25195
25196
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25197
695
{
25198
695
  USE_OPLINE
25199
695
  zval *object_ptr, *orig_object_ptr;
25200
695
  zval *value;
25201
695
  zval *variable_ptr;
25202
695
  zval *dim;
25203
695
  zend_refcounted *garbage = NULL;
25204
25205
695
  SAVE_OPLINE();
25206
695
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25207
25208
695
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25209
695
try_assign_dim_array:
25210
695
    SEPARATE_ARRAY(object_ptr);
25211
695
    if (IS_CONST == IS_UNUSED) {
25212
0
      value = EX_VAR((opline+1)->op1.var);
25213
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
25214
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
25215
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
25216
0
          GC_ADDREF(ht);
25217
0
        }
25218
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25219
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
25220
0
          zend_array_destroy(ht);
25221
0
          goto assign_dim_error;
25222
0
        }
25223
0
      }
25224
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
25225
0
        ZVAL_DEREF(value);
25226
0
      }
25227
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
25228
0
      if (UNEXPECTED(value == NULL)) {
25229
0
        zend_cannot_add_element();
25230
0
        goto assign_dim_error;
25231
0
      } else if (IS_CV == IS_CV) {
25232
0
        if (Z_REFCOUNTED_P(value)) {
25233
0
          Z_ADDREF_P(value);
25234
0
        }
25235
0
      } else if (IS_CV == IS_VAR) {
25236
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
25237
0
        if (Z_ISREF_P(free_op_data)) {
25238
0
          if (Z_REFCOUNTED_P(value)) {
25239
0
            Z_ADDREF_P(value);
25240
0
          }
25241
0
          zval_ptr_dtor_nogc(free_op_data);
25242
0
        }
25243
0
      } else if (IS_CV == IS_CONST) {
25244
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
25245
0
          Z_ADDREF_P(value);
25246
0
        }
25247
0
      }
25248
695
    } else {
25249
695
      dim = RT_CONSTANT(opline, opline->op2);
25250
695
      if (IS_CONST == IS_CONST) {
25251
695
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25252
695
      } else {
25253
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25254
0
      }
25255
695
      if (UNEXPECTED(variable_ptr == NULL)) {
25256
0
        goto assign_dim_error;
25257
0
      }
25258
695
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
25259
695
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
25260
695
    }
25261
695
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25262
156
      ZVAL_COPY(EX_VAR(opline->result.var), value);
25263
156
    }
25264
695
    if (garbage) {
25265
0
      GC_DTOR_NO_REF(garbage);
25266
0
    }
25267
695
  } else {
25268
142
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
25269
0
      object_ptr = Z_REFVAL_P(object_ptr);
25270
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25271
0
        goto try_assign_dim_array;
25272
0
      }
25273
0
    }
25274
142
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
25275
0
      zend_object *obj = Z_OBJ_P(object_ptr);
25276
25277
0
      GC_ADDREF(obj);
25278
0
      dim = RT_CONSTANT(opline, opline->op2);
25279
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
25280
0
        dim = ZVAL_UNDEFINED_OP2();
25281
0
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
25282
0
        dim++;
25283
0
      }
25284
25285
0
      value = EX_VAR((opline+1)->op1.var);
25286
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
25287
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25288
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
25289
0
        ZVAL_DEREF(value);
25290
0
      }
25291
25292
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
25293
25294
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
25295
0
        zend_objects_store_del(obj);
25296
0
      }
25297
142
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
25298
0
      if (IS_CONST == IS_UNUSED) {
25299
0
        zend_use_new_element_for_string();
25300
25301
0
        UNDEF_RESULT();
25302
0
      } else {
25303
0
        dim = RT_CONSTANT(opline, opline->op2);
25304
0
        value = EX_VAR((opline+1)->op1.var);
25305
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25306
25307
0
      }
25308
142
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25309
142
      if (Z_ISREF_P(orig_object_ptr)
25310
142
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25311
142
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25312
0
        dim = RT_CONSTANT(opline, opline->op2);
25313
25314
0
        UNDEF_RESULT();
25315
142
      } else {
25316
142
        HashTable *ht = zend_new_array(8);
25317
142
        uint8_t old_type = Z_TYPE_P(object_ptr);
25318
25319
142
        ZVAL_ARR(object_ptr, ht);
25320
142
        if (UNEXPECTED(old_type == IS_FALSE)) {
25321
0
          GC_ADDREF(ht);
25322
0
          zend_false_to_array_deprecated();
25323
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25324
0
            zend_array_destroy(ht);
25325
0
            goto assign_dim_error;
25326
0
          }
25327
0
        }
25328
142
        goto try_assign_dim_array;
25329
142
      }
25330
142
    } else {
25331
0
      zend_use_scalar_as_array();
25332
0
      dim = RT_CONSTANT(opline, opline->op2);
25333
0
assign_dim_error:
25334
25335
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25336
0
        ZVAL_NULL(EX_VAR(opline->result.var));
25337
0
      }
25338
0
    }
25339
142
  }
25340
695
  if (IS_CONST != IS_UNUSED) {
25341
25342
695
  }
25343
695
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25344
  /* assign_dim has two opcodes! */
25345
695
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25346
695
}
25347
25348
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25349
1.49k
{
25350
1.49k
  USE_OPLINE
25351
1.49k
  zval *value;
25352
1.49k
  zval *variable_ptr;
25353
25354
1.49k
  SAVE_OPLINE();
25355
1.49k
  value = RT_CONSTANT(opline, opline->op2);
25356
1.49k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25357
25358
1.49k
  if (0 || UNEXPECTED(0)) {
25359
0
    zend_refcounted *garbage = NULL;
25360
25361
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
25362
0
    if (UNEXPECTED(0)) {
25363
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
25364
0
    }
25365
0
    if (garbage) {
25366
0
      GC_DTOR_NO_REF(garbage);
25367
0
    }
25368
1.49k
  } else {
25369
1.49k
    value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
25370
1.49k
  }
25371
1.49k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25372
  /* zend_assign_to_variable() always takes care of op2, never free it! */
25373
25374
1.49k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25375
1.49k
}
25376
25377
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25378
424
{
25379
424
  USE_OPLINE
25380
424
  zval *value;
25381
424
  zval *variable_ptr;
25382
25383
424
  SAVE_OPLINE();
25384
424
  value = RT_CONSTANT(opline, opline->op2);
25385
424
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25386
25387
424
  if (0 || UNEXPECTED(1)) {
25388
424
    zend_refcounted *garbage = NULL;
25389
25390
424
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
25391
424
    if (UNEXPECTED(1)) {
25392
424
      ZVAL_COPY(EX_VAR(opline->result.var), value);
25393
424
    }
25394
424
    if (garbage) {
25395
0
      GC_DTOR_NO_REF(garbage);
25396
0
    }
25397
424
  } else {
25398
0
    value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
25399
0
  }
25400
424
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25401
  /* zend_assign_to_variable() always takes care of op2, never free it! */
25402
25403
424
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25404
424
}
25405
25406
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25407
29
{
25408
29
  USE_OPLINE
25409
29
  zval *property, *container, *value_ptr;
25410
25411
29
  SAVE_OPLINE();
25412
25413
29
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25414
29
  property = RT_CONSTANT(opline, opline->op2);
25415
25416
29
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25417
25418
29
  if (1) {
25419
29
    if (IS_VAR == IS_UNUSED) {
25420
0
      if (IS_CONST == IS_CONST) {
25421
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25422
0
      } else {
25423
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25424
0
      }
25425
29
    } else {
25426
29
      if (IS_CONST == IS_CONST) {
25427
29
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25428
29
      } else {
25429
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25430
0
      }
25431
29
    }
25432
29
  } else {
25433
0
    zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25434
0
  }
25435
25436
29
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25437
25438
29
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25439
29
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25440
29
}
25441
25442
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
25443
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25444
23
{
25445
23
  USE_OPLINE
25446
23
  zval *property, *container, *value_ptr;
25447
25448
23
  SAVE_OPLINE();
25449
25450
23
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25451
23
  property = RT_CONSTANT(opline, opline->op2);
25452
25453
23
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
25454
25455
23
  if (1) {
25456
23
    if (IS_VAR == IS_UNUSED) {
25457
0
      if (IS_CONST == IS_CONST) {
25458
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25459
0
      } else {
25460
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25461
0
      }
25462
23
    } else {
25463
23
      if (IS_CONST == IS_CONST) {
25464
23
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25465
23
      } else {
25466
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25467
0
      }
25468
23
    }
25469
23
  } else {
25470
0
    zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25471
0
  }
25472
25473
23
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25474
25475
25476
23
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
25477
23
}
25478
25479
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
25480
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25481
159
{
25482
159
  USE_OPLINE
25483
159
  zval *function_name;
25484
159
  zend_class_entry *ce;
25485
159
  uint32_t call_info;
25486
159
  zend_function *fbc;
25487
159
  zend_execute_data *call;
25488
25489
159
  SAVE_OPLINE();
25490
25491
159
  if (IS_VAR == IS_CONST) {
25492
    /* no function found. try a static method in class */
25493
0
    ce = CACHED_PTR(opline->result.num);
25494
0
    if (UNEXPECTED(ce == NULL)) {
25495
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);
25496
0
      if (UNEXPECTED(ce == NULL)) {
25497
25498
0
        HANDLE_EXCEPTION();
25499
0
      }
25500
0
      if (IS_CONST != IS_CONST) {
25501
0
        CACHE_PTR(opline->result.num, ce);
25502
0
      }
25503
0
    }
25504
159
  } else if (IS_VAR == IS_UNUSED) {
25505
0
    ce = zend_fetch_class(NULL, opline->op1.num);
25506
0
    if (UNEXPECTED(ce == NULL)) {
25507
25508
0
      HANDLE_EXCEPTION();
25509
0
    }
25510
159
  } else {
25511
159
    ce = Z_CE_P(EX_VAR(opline->op1.var));
25512
159
  }
25513
25514
159
  if (IS_VAR == IS_CONST &&
25515
159
      IS_CONST == IS_CONST &&
25516
159
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
25517
    /* nothing to do */
25518
159
  } else if (IS_VAR != IS_CONST &&
25519
159
             IS_CONST == IS_CONST &&
25520
159
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
25521
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
25522
159
  } else if (IS_CONST != IS_UNUSED) {
25523
159
    function_name = RT_CONSTANT(opline, opline->op2);
25524
159
    if (IS_CONST != IS_CONST) {
25525
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
25526
0
        do {
25527
0
          if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
25528
0
            function_name = Z_REFVAL_P(function_name);
25529
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
25530
0
              break;
25531
0
            }
25532
0
          } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
25533
0
            ZVAL_UNDEFINED_OP2();
25534
0
            if (UNEXPECTED(EG(exception) != NULL)) {
25535
0
              HANDLE_EXCEPTION();
25536
0
            }
25537
0
          }
25538
0
          zend_throw_error(NULL, "Method name must be a string");
25539
25540
0
          HANDLE_EXCEPTION();
25541
0
        } while (0);
25542
0
      }
25543
0
    }
25544
25545
159
    if (ce->get_static_method) {
25546
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
25547
159
    } else {
25548
159
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
25549
159
    }
25550
159
    if (UNEXPECTED(fbc == NULL)) {
25551
7
      if (EXPECTED(!EG(exception))) {
25552
7
        zend_undefined_method(ce, Z_STR_P(function_name));
25553
7
      }
25554
25555
7
      HANDLE_EXCEPTION();
25556
7
    }
25557
152
    if (IS_CONST == IS_CONST &&
25558
152
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
25559
152
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
25560
112
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
25561
112
    }
25562
152
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
25563
33
      init_func_run_time_cache(&fbc->op_array);
25564
33
    }
25565
152
    if (IS_CONST != IS_CONST) {
25566
25567
0
    }
25568
152
  } else {
25569
0
    if (UNEXPECTED(ce->constructor == NULL)) {
25570
0
      zend_throw_error(NULL, "Cannot call constructor");
25571
0
      HANDLE_EXCEPTION();
25572
0
    }
25573
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)) {
25574
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
25575
0
      HANDLE_EXCEPTION();
25576
0
    }
25577
0
    fbc = ce->constructor;
25578
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
25579
0
      init_func_run_time_cache(&fbc->op_array);
25580
0
    }
25581
0
  }
25582
25583
152
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
25584
10
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
25585
5
      ce = (zend_class_entry*)Z_OBJ(EX(This));
25586
5
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
25587
5
    } else {
25588
5
      zend_non_static_method_call(fbc);
25589
5
      HANDLE_EXCEPTION();
25590
5
    }
25591
142
  } else {
25592
    /* previous opcode is ZEND_FETCH_CLASS */
25593
142
    if (IS_VAR == IS_UNUSED
25594
142
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
25595
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
25596
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
25597
0
        ce = Z_OBJCE(EX(This));
25598
0
      } else {
25599
0
        ce = Z_CE(EX(This));
25600
0
      }
25601
0
    }
25602
142
    call_info = ZEND_CALL_NESTED_FUNCTION;
25603
142
  }
25604
25605
147
  call = zend_vm_stack_push_call_frame(call_info,
25606
147
    fbc, opline->extended_value, ce);
25607
147
  call->prev_execute_data = EX(call);
25608
147
  EX(call) = call;
25609
25610
147
  ZEND_VM_NEXT_OPCODE();
25611
147
}
25612
25613
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25614
0
{
25615
0
  USE_OPLINE
25616
0
  zval *varptr, *arg;
25617
25618
0
  if (IS_CONST == IS_CONST) {
25619
0
    SAVE_OPLINE();
25620
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25621
0
    uint32_t arg_num;
25622
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25623
0
    if (UNEXPECTED(!arg)) {
25624
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25625
0
      HANDLE_EXCEPTION();
25626
0
    }
25627
0
  } else {
25628
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25629
0
  }
25630
25631
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25632
0
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25633
0
    SAVE_OPLINE();
25634
0
    ZVAL_UNDEFINED_OP1();
25635
0
    ZVAL_NULL(arg);
25636
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25637
0
  }
25638
25639
0
  if (IS_VAR == IS_CV) {
25640
0
    ZVAL_COPY_DEREF(arg, varptr);
25641
0
  } else /* if (IS_VAR == IS_VAR) */ {
25642
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
25643
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
25644
25645
0
      varptr = Z_REFVAL_P(varptr);
25646
0
      ZVAL_COPY_VALUE(arg, varptr);
25647
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25648
0
        efree_size(ref, sizeof(zend_reference));
25649
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
25650
0
        Z_ADDREF_P(arg);
25651
0
      }
25652
0
    } else {
25653
0
      ZVAL_COPY_VALUE(arg, varptr);
25654
0
    }
25655
0
  }
25656
25657
0
  ZEND_VM_NEXT_OPCODE();
25658
0
}
25659
25660
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25661
64
{
25662
64
  USE_OPLINE
25663
64
  zval *varptr, *arg;
25664
25665
64
  if (IS_CONST == IS_CONST) {
25666
64
    SAVE_OPLINE();
25667
64
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25668
64
    uint32_t arg_num;
25669
64
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25670
64
    if (UNEXPECTED(!arg)) {
25671
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25672
0
      HANDLE_EXCEPTION();
25673
0
    }
25674
64
  } else {
25675
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25676
0
  }
25677
25678
64
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25679
64
  ZVAL_COPY_VALUE(arg, varptr);
25680
25681
64
  if (EXPECTED(Z_ISREF_P(varptr))) {
25682
64
    ZEND_VM_NEXT_OPCODE();
25683
64
  }
25684
25685
64
  SAVE_OPLINE();
25686
0
  ZVAL_NEW_REF(arg, arg);
25687
0
  zend_error(E_NOTICE, "Only variables should be passed by reference");
25688
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25689
0
}
25690
25691
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25692
64
{
25693
64
  USE_OPLINE
25694
64
  zval *varptr, *arg;
25695
64
  uint32_t arg_num;
25696
25697
64
  if (IS_CONST == IS_CONST) {
25698
64
    SAVE_OPLINE();
25699
64
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25700
64
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25701
64
    if (UNEXPECTED(!arg)) {
25702
8
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25703
8
      HANDLE_EXCEPTION();
25704
8
    }
25705
64
  } else {
25706
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25707
0
    arg_num = opline->op2.num;
25708
0
  }
25709
25710
56
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25711
56
    if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25712
0
      goto send_var;
25713
0
    }
25714
25715
56
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25716
56
    ZVAL_COPY_VALUE(arg, varptr);
25717
25718
56
    if (EXPECTED(Z_ISREF_P(varptr) ||
25719
56
        QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25720
56
      ZEND_VM_NEXT_OPCODE();
25721
56
    }
25722
56
  } else {
25723
0
    if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25724
0
      goto send_var;
25725
0
    }
25726
25727
0
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25728
0
    ZVAL_COPY_VALUE(arg, varptr);
25729
25730
0
    if (EXPECTED(Z_ISREF_P(varptr) ||
25731
0
        ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25732
0
      ZEND_VM_NEXT_OPCODE();
25733
0
    }
25734
0
  }
25735
25736
56
  SAVE_OPLINE();
25737
0
  ZVAL_NEW_REF(arg, arg);
25738
0
  zend_error(E_NOTICE, "Only variables should be passed by reference");
25739
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25740
25741
0
send_var:
25742
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25743
0
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
25744
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
25745
25746
0
    varptr = Z_REFVAL_P(varptr);
25747
0
    ZVAL_COPY_VALUE(arg, varptr);
25748
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25749
0
      efree_size(ref, sizeof(zend_reference));
25750
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
25751
0
      Z_ADDREF_P(arg);
25752
0
    }
25753
0
  } else {
25754
0
    ZVAL_COPY_VALUE(arg, varptr);
25755
0
  }
25756
0
  ZEND_VM_NEXT_OPCODE();
25757
0
}
25758
25759
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25760
20
{
25761
20
  USE_OPLINE
25762
20
  zval *varptr, *arg;
25763
25764
20
  SAVE_OPLINE();
25765
20
  if (IS_CONST == IS_CONST) {
25766
20
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25767
20
    uint32_t arg_num;
25768
20
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25769
20
    if (UNEXPECTED(!arg)) {
25770
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25771
0
      HANDLE_EXCEPTION();
25772
0
    }
25773
20
  } else {
25774
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25775
0
  }
25776
25777
20
  varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25778
20
  if (Z_ISREF_P(varptr)) {
25779
0
    Z_ADDREF_P(varptr);
25780
20
  } else {
25781
20
    ZVAL_MAKE_REF_EX(varptr, 2);
25782
20
  }
25783
20
  ZVAL_REF(arg, Z_REF_P(varptr));
25784
25785
20
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25786
20
  ZEND_VM_NEXT_OPCODE();
25787
20
}
25788
25789
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25790
0
{
25791
0
  USE_OPLINE
25792
0
  zval *varptr, *arg;
25793
0
  uint32_t arg_num;
25794
25795
0
  if (IS_CONST == IS_CONST) {
25796
0
    SAVE_OPLINE();
25797
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25798
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25799
0
    if (UNEXPECTED(!arg)) {
25800
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25801
0
      HANDLE_EXCEPTION();
25802
0
    }
25803
0
  } else {
25804
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25805
0
    arg_num = opline->op2.num;
25806
0
  }
25807
25808
0
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25809
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25810
0
      goto send_var_by_ref;
25811
0
    }
25812
0
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25813
0
send_var_by_ref:
25814
0
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25815
0
    if (Z_ISREF_P(varptr)) {
25816
0
      Z_ADDREF_P(varptr);
25817
0
    } else {
25818
0
      ZVAL_MAKE_REF_EX(varptr, 2);
25819
0
    }
25820
0
    ZVAL_REF(arg, Z_REF_P(varptr));
25821
25822
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25823
0
    ZEND_VM_NEXT_OPCODE();
25824
0
  }
25825
25826
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25827
0
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25828
0
    SAVE_OPLINE();
25829
0
    ZVAL_UNDEFINED_OP1();
25830
0
    ZVAL_NULL(arg);
25831
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25832
0
  }
25833
25834
0
  if (IS_VAR == IS_CV) {
25835
0
    ZVAL_COPY_DEREF(arg, varptr);
25836
0
  } else /* if (IS_VAR == IS_VAR) */ {
25837
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
25838
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
25839
25840
0
      varptr = Z_REFVAL_P(varptr);
25841
0
      ZVAL_COPY_VALUE(arg, varptr);
25842
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25843
0
        efree_size(ref, sizeof(zend_reference));
25844
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
25845
0
        Z_ADDREF_P(arg);
25846
0
      }
25847
0
    } else {
25848
0
      ZVAL_COPY_VALUE(arg, varptr);
25849
0
    }
25850
0
  }
25851
25852
0
  ZEND_VM_NEXT_OPCODE();
25853
0
}
25854
25855
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25856
48
{
25857
48
  USE_OPLINE
25858
48
  zval *varptr, *arg;
25859
25860
48
  if (IS_CONST == IS_CONST) {
25861
    // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
25862
48
    SAVE_OPLINE();
25863
48
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25864
48
    uint32_t arg_num;
25865
48
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25866
48
    if (UNEXPECTED(!arg)) {
25867
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25868
0
      HANDLE_EXCEPTION();
25869
0
    }
25870
48
  } else {
25871
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25872
0
  }
25873
25874
48
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
25875
22
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25876
22
    if (Z_ISREF_P(varptr)) {
25877
0
      Z_ADDREF_P(varptr);
25878
22
    } else {
25879
22
      ZVAL_MAKE_REF_EX(varptr, 2);
25880
22
    }
25881
22
    ZVAL_REF(arg, Z_REF_P(varptr));
25882
25883
22
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25884
22
    ZEND_VM_NEXT_OPCODE();
25885
22
  }
25886
25887
26
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25888
25889
26
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
25890
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
25891
25892
0
    varptr = Z_REFVAL_P(varptr);
25893
0
    ZVAL_COPY_VALUE(arg, varptr);
25894
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25895
0
      efree_size(ref, sizeof(zend_reference));
25896
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
25897
0
      Z_ADDREF_P(arg);
25898
0
    }
25899
26
  } else {
25900
26
    ZVAL_COPY_VALUE(arg, varptr);
25901
26
  }
25902
25903
26
  ZEND_VM_NEXT_OPCODE();
25904
26
}
25905
25906
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25907
182
{
25908
182
  zend_class_entry *ce, *scope;
25909
182
  zend_class_constant *c;
25910
182
  zval *value, *zv, *constant_zv;
25911
182
  zend_string *constant_name;
25912
182
  USE_OPLINE
25913
25914
182
  SAVE_OPLINE();
25915
25916
182
  do {
25917
182
    if (IS_VAR == IS_CONST && IS_CONST == IS_CONST) {
25918
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
25919
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
25920
0
        break;
25921
0
      }
25922
0
    }
25923
182
    if (IS_VAR == IS_CONST) {
25924
0
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
25925
0
        ce = CACHED_PTR(opline->extended_value);
25926
0
      } else {
25927
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);
25928
0
        if (UNEXPECTED(ce == NULL)) {
25929
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
25930
25931
0
          HANDLE_EXCEPTION();
25932
0
        }
25933
0
        CACHE_PTR(opline->extended_value, ce);
25934
0
      }
25935
182
    } else if (IS_VAR == IS_UNUSED) {
25936
0
      ce = zend_fetch_class(NULL, opline->op1.num);
25937
0
      if (UNEXPECTED(ce == NULL)) {
25938
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
25939
25940
0
        HANDLE_EXCEPTION();
25941
0
      }
25942
182
    } else {
25943
182
      ce = Z_CE_P(EX_VAR(opline->op1.var));
25944
182
    }
25945
182
    if (IS_VAR != IS_CONST
25946
182
      && IS_CONST == IS_CONST
25947
182
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
25948
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
25949
0
      break;
25950
0
    }
25951
25952
182
    constant_zv = RT_CONSTANT(opline, opline->op2);
25953
182
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
25954
20
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
25955
20
      ZVAL_UNDEF(EX_VAR(opline->result.var));
25956
25957
20
      HANDLE_EXCEPTION();
25958
20
    }
25959
162
    constant_name = Z_STR_P(constant_zv);
25960
    /* Magic 'class' for constant OP2 is caught at compile-time */
25961
162
    if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
25962
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
25963
25964
0
      ZEND_VM_NEXT_OPCODE();
25965
0
    }
25966
162
    zv = IS_CONST == IS_CONST
25967
162
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
25968
162
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
25969
25970
162
    if (EXPECTED(zv != NULL)) {
25971
155
      c = Z_PTR_P(zv);
25972
155
      scope = EX(func)->op_array.scope;
25973
155
      if (!zend_verify_const_access(c, scope)) {
25974
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));
25975
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
25976
25977
0
        HANDLE_EXCEPTION();
25978
0
      }
25979
25980
155
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
25981
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25982
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
25983
25984
0
        HANDLE_EXCEPTION();
25985
0
      }
25986
25987
155
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
25988
155
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
25989
0
        if (c->ce->type == ZEND_USER_CLASS) {
25990
          /* Recursion protection only applied to user constants, GH-18463 */
25991
0
          CONST_PROTECT_RECURSION(c);
25992
0
        }
25993
0
        zend_deprecated_class_constant(c, constant_name);
25994
0
        if (c->ce->type == ZEND_USER_CLASS) {
25995
0
          CONST_UNPROTECT_RECURSION(c);
25996
0
        }
25997
25998
0
        if (EG(exception)) {
25999
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26000
26001
0
          HANDLE_EXCEPTION();
26002
0
        }
26003
0
      }
26004
26005
155
      value = &c->value;
26006
      // Enums require loading of all class constants to build the backed enum table
26007
155
      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)) {
26008
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
26009
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26010
26011
0
          HANDLE_EXCEPTION();
26012
0
        }
26013
0
      }
26014
155
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
26015
0
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
26016
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26017
26018
0
          HANDLE_EXCEPTION();
26019
0
        }
26020
0
      }
26021
155
      if (IS_CONST == IS_CONST && !is_constant_deprecated) {
26022
155
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
26023
155
      }
26024
155
    } else {
26025
7
      zend_throw_error(NULL, "Undefined constant %s::%s",
26026
7
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26027
7
      ZVAL_UNDEF(EX_VAR(opline->result.var));
26028
26029
7
      HANDLE_EXCEPTION();
26030
7
    }
26031
162
  } while (0);
26032
26033
155
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
26034
26035
155
  ZEND_VM_NEXT_OPCODE();
26036
155
}
26037
26038
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26039
270
{
26040
270
  USE_OPLINE
26041
270
  zval *expr_ptr, new_expr;
26042
26043
270
  SAVE_OPLINE();
26044
270
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
26045
270
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
26046
0
    expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26047
0
    if (Z_ISREF_P(expr_ptr)) {
26048
0
      Z_ADDREF_P(expr_ptr);
26049
0
    } else {
26050
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
26051
0
    }
26052
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26053
270
  } else {
26054
270
    expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26055
270
    if (IS_VAR == IS_TMP_VAR) {
26056
      /* pass */
26057
270
    } else if (IS_VAR == IS_CONST) {
26058
0
      Z_TRY_ADDREF_P(expr_ptr);
26059
270
    } else if (IS_VAR == IS_CV) {
26060
0
      ZVAL_DEREF(expr_ptr);
26061
0
      Z_TRY_ADDREF_P(expr_ptr);
26062
270
    } else /* if (IS_VAR == IS_VAR) */ {
26063
270
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
26064
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
26065
26066
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
26067
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
26068
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
26069
0
          expr_ptr = &new_expr;
26070
0
          efree_size(ref, sizeof(zend_reference));
26071
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
26072
0
          Z_ADDREF_P(expr_ptr);
26073
0
        }
26074
0
      }
26075
270
    }
26076
270
  }
26077
26078
270
  if (IS_CONST != IS_UNUSED) {
26079
270
    zval *offset = RT_CONSTANT(opline, opline->op2);
26080
270
    zend_string *str;
26081
270
    zend_ulong hval;
26082
26083
270
add_again:
26084
270
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
26085
239
      str = Z_STR_P(offset);
26086
239
      if (IS_CONST != IS_CONST) {
26087
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
26088
0
          goto num_index;
26089
0
        }
26090
0
      }
26091
239
str_index:
26092
239
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
26093
239
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
26094
28
      hval = Z_LVAL_P(offset);
26095
31
num_index:
26096
31
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
26097
31
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
26098
0
      offset = Z_REFVAL_P(offset);
26099
0
      goto add_again;
26100
3
    } else if (Z_TYPE_P(offset) == IS_NULL) {
26101
0
      str = ZSTR_EMPTY_ALLOC();
26102
0
      goto str_index;
26103
3
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
26104
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
26105
0
      goto num_index;
26106
3
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
26107
3
      hval = 0;
26108
3
      goto num_index;
26109
3
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
26110
0
      hval = 1;
26111
0
      goto num_index;
26112
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
26113
0
      zend_use_resource_as_offset(offset);
26114
0
      hval = Z_RES_HANDLE_P(offset);
26115
0
      goto num_index;
26116
0
    } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
26117
0
      ZVAL_UNDEFINED_OP2();
26118
0
      str = ZSTR_EMPTY_ALLOC();
26119
0
      goto str_index;
26120
0
    } else {
26121
0
      zend_illegal_array_offset_access(offset);
26122
0
      zval_ptr_dtor_nogc(expr_ptr);
26123
0
    }
26124
26125
270
  } else {
26126
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
26127
0
      zend_cannot_add_element();
26128
0
      zval_ptr_dtor_nogc(expr_ptr);
26129
0
    }
26130
0
  }
26131
270
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26132
270
}
26133
26134
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26135
142
{
26136
142
  zval *array;
26137
142
  uint32_t size;
26138
142
  USE_OPLINE
26139
26140
142
  SAVE_OPLINE();
26141
142
  array = EX_VAR(opline->result.var);
26142
142
  if (IS_VAR != IS_UNUSED) {
26143
142
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
26144
142
    ZVAL_ARR(array, zend_new_array(size));
26145
    /* Explicitly initialize array as not-packed if flag is set */
26146
142
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
26147
127
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
26148
127
    }
26149
142
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26150
142
  } else {
26151
0
    ZVAL_ARR(array, zend_new_array(0));
26152
0
    ZEND_VM_NEXT_OPCODE();
26153
0
  }
26154
142
}
26155
26156
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26157
183
{
26158
183
  USE_OPLINE
26159
183
  zval *container;
26160
183
  zval *offset;
26161
183
  zend_ulong hval;
26162
183
  zend_string *key;
26163
26164
183
  SAVE_OPLINE();
26165
183
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26166
183
  offset = RT_CONSTANT(opline, opline->op2);
26167
26168
183
  do {
26169
183
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26170
75
      HashTable *ht;
26171
26172
75
unset_dim_array:
26173
75
      SEPARATE_ARRAY(container);
26174
75
      ht = Z_ARRVAL_P(container);
26175
75
offset_again:
26176
75
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
26177
34
        key = Z_STR_P(offset);
26178
34
        if (IS_CONST != IS_CONST) {
26179
0
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
26180
0
            goto num_index_dim;
26181
0
          }
26182
0
        }
26183
34
str_index_dim:
26184
34
        ZEND_ASSERT(ht != &EG(symbol_table));
26185
34
        zend_hash_del(ht, key);
26186
41
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
26187
41
        hval = Z_LVAL_P(offset);
26188
41
num_index_dim:
26189
41
        zend_hash_index_del(ht, hval);
26190
41
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
26191
0
        offset = Z_REFVAL_P(offset);
26192
0
        goto offset_again;
26193
0
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
26194
0
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
26195
0
        goto num_index_dim;
26196
0
      } else if (Z_TYPE_P(offset) == IS_NULL) {
26197
0
        key = ZSTR_EMPTY_ALLOC();
26198
0
        goto str_index_dim;
26199
0
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
26200
0
        hval = 0;
26201
0
        goto num_index_dim;
26202
0
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
26203
0
        hval = 1;
26204
0
        goto num_index_dim;
26205
0
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
26206
0
        zend_use_resource_as_offset(offset);
26207
0
        hval = Z_RES_HANDLE_P(offset);
26208
0
        goto num_index_dim;
26209
0
      } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
26210
0
        ZVAL_UNDEFINED_OP2();
26211
0
        key = ZSTR_EMPTY_ALLOC();
26212
0
        goto str_index_dim;
26213
0
      } else {
26214
0
        zend_illegal_array_offset_unset(offset);
26215
0
      }
26216
75
      break;
26217
108
    } else if (Z_ISREF_P(container)) {
26218
0
      container = Z_REFVAL_P(container);
26219
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26220
0
        goto unset_dim_array;
26221
0
      }
26222
0
    }
26223
108
    if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
26224
0
      container = ZVAL_UNDEFINED_OP1();
26225
0
    }
26226
108
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
26227
0
      offset = ZVAL_UNDEFINED_OP2();
26228
0
    }
26229
108
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26230
19
      if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
26231
0
        offset++;
26232
0
      }
26233
19
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
26234
89
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
26235
0
      zend_throw_error(NULL, "Cannot unset string offsets");
26236
89
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
26237
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
26238
89
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
26239
0
      zend_false_to_array_deprecated();
26240
0
    }
26241
108
  } while (0);
26242
26243
183
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26244
183
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26245
183
}
26246
26247
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26248
39
{
26249
39
  USE_OPLINE
26250
39
  zval *container;
26251
39
  zval *offset;
26252
39
  zend_string *name, *tmp_name;
26253
26254
39
  SAVE_OPLINE();
26255
39
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26256
39
  offset = RT_CONSTANT(opline, opline->op2);
26257
26258
39
  do {
26259
39
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
26260
27
      if (Z_ISREF_P(container)) {
26261
0
        container = Z_REFVAL_P(container);
26262
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
26263
0
          if (IS_VAR == IS_CV
26264
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
26265
0
            ZVAL_UNDEFINED_OP1();
26266
0
          }
26267
0
          break;
26268
0
        }
26269
27
      } else {
26270
27
        break;
26271
27
      }
26272
27
    }
26273
12
    if (IS_CONST == IS_CONST) {
26274
12
      name = Z_STR_P(offset);
26275
12
    } else {
26276
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
26277
0
      if (UNEXPECTED(!name)) {
26278
0
        break;
26279
0
      }
26280
0
    }
26281
12
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
26282
12
    if (IS_CONST != IS_CONST) {
26283
0
      zend_tmp_string_release(tmp_name);
26284
0
    }
26285
12
  } while (0);
26286
26287
39
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26288
39
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26289
39
}
26290
26291
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26292
36
{
26293
36
  USE_OPLINE
26294
26295
36
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
26296
26297
36
  SAVE_OPLINE();
26298
36
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
26299
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26300
0
  }
26301
26302
  /* Destroy the previously yielded value */
26303
36
  zval_ptr_dtor(&generator->value);
26304
26305
  /* Destroy the previously yielded key */
26306
36
  zval_ptr_dtor(&generator->key);
26307
26308
  /* Set the new yielded value */
26309
36
  if (IS_VAR != IS_UNUSED) {
26310
36
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
26311
      /* Constants and temporary variables aren't yieldable by reference,
26312
       * but we still allow them with a notice. */
26313
0
      if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
26314
0
        zval *value;
26315
26316
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26317
26318
0
        value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26319
0
        ZVAL_COPY_VALUE(&generator->value, value);
26320
0
        if (IS_VAR == IS_CONST) {
26321
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
26322
0
            Z_ADDREF(generator->value);
26323
0
          }
26324
0
        }
26325
0
      } else {
26326
0
        zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26327
26328
        /* If a function call result is yielded and the function did
26329
         * not return by reference we throw a notice. */
26330
0
        do {
26331
0
          if (IS_VAR == IS_VAR) {
26332
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
26333
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
26334
0
             && !Z_ISREF_P(value_ptr)) {
26335
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26336
0
              ZVAL_COPY(&generator->value, value_ptr);
26337
0
              break;
26338
0
            }
26339
0
          }
26340
0
          if (Z_ISREF_P(value_ptr)) {
26341
0
            Z_ADDREF_P(value_ptr);
26342
0
          } else {
26343
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
26344
0
          }
26345
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
26346
0
        } while (0);
26347
26348
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26349
0
      }
26350
36
    } else {
26351
36
      zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26352
26353
      /* Consts, temporary variables and references need copying */
26354
36
      if (IS_VAR == IS_CONST) {
26355
0
        ZVAL_COPY_VALUE(&generator->value, value);
26356
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
26357
0
          Z_ADDREF(generator->value);
26358
0
        }
26359
36
      } else if (IS_VAR == IS_TMP_VAR) {
26360
0
        ZVAL_COPY_VALUE(&generator->value, value);
26361
36
      } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
26362
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
26363
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26364
36
      } else {
26365
36
        ZVAL_COPY_VALUE(&generator->value, value);
26366
36
        if (IS_VAR == IS_CV) {
26367
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
26368
0
        }
26369
36
      }
26370
36
    }
26371
36
  } else {
26372
    /* If no value was specified yield null */
26373
0
    ZVAL_NULL(&generator->value);
26374
0
  }
26375
26376
  /* Set the new yielded key */
26377
36
  if (IS_CONST != IS_UNUSED) {
26378
36
    zval *key = RT_CONSTANT(opline, opline->op2);
26379
36
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
26380
0
      key = Z_REFVAL_P(key);
26381
0
    }
26382
36
    ZVAL_COPY(&generator->key, key);
26383
26384
36
    if (Z_TYPE(generator->key) == IS_LONG
26385
36
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
26386
36
    ) {
26387
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
26388
0
    }
26389
36
  } else {
26390
    /* If no key was specified we use auto-increment keys */
26391
0
    generator->largest_used_integer_key++;
26392
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
26393
0
  }
26394
26395
36
  if (RETURN_VALUE_USED(opline)) {
26396
    /* If the return value of yield is used set the send
26397
     * target and initialize it to NULL */
26398
36
    generator->send_target = EX_VAR(opline->result.var);
26399
36
    ZVAL_NULL(generator->send_target);
26400
36
  } else {
26401
0
    generator->send_target = NULL;
26402
0
  }
26403
26404
  /* The GOTO VM uses a local opline variable. We need to set the opline
26405
   * variable in execute_data so we don't resume at an old position. */
26406
36
  SAVE_OPLINE();
26407
26408
36
  ZEND_VM_RETURN();
26409
36
}
26410
26411
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26412
0
{
26413
0
  USE_OPLINE
26414
0
  zval *op1;
26415
0
  HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
26416
0
  zval *result;
26417
26418
0
  op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26419
0
  if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26420
0
    result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_VAR == IS_CONST);
26421
0
    if (IS_VAR & (IS_TMP_VAR|IS_VAR)) {
26422
0
      zval_ptr_dtor_str(op1);
26423
0
    }
26424
0
    ZEND_VM_SMART_BRANCH(result, 0);
26425
0
  }
26426
26427
0
  if (opline->extended_value) {
26428
0
    if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
26429
0
      result = zend_hash_index_find(ht, Z_LVAL_P(op1));
26430
0
      ZEND_VM_SMART_BRANCH(result, 0);
26431
0
    }
26432
0
    SAVE_OPLINE();
26433
0
    if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
26434
0
      op1 = Z_REFVAL_P(op1);
26435
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26436
0
        result = zend_hash_find(ht, Z_STR_P(op1));
26437
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26438
0
        ZEND_VM_SMART_BRANCH(result, 0);
26439
0
      } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
26440
0
        result = zend_hash_index_find(ht, Z_LVAL_P(op1));
26441
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26442
0
        ZEND_VM_SMART_BRANCH(result, 0);
26443
0
      }
26444
0
    } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
26445
0
      ZVAL_UNDEFINED_OP1();
26446
0
    }
26447
0
  } else if (Z_TYPE_P(op1) <= IS_FALSE) {
26448
0
    if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
26449
0
      SAVE_OPLINE();
26450
0
      ZVAL_UNDEFINED_OP1();
26451
0
      if (UNEXPECTED(EG(exception) != NULL)) {
26452
0
        HANDLE_EXCEPTION();
26453
0
      }
26454
0
    }
26455
0
    result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
26456
0
    ZEND_VM_SMART_BRANCH(result, 0);
26457
0
  } else {
26458
0
    zend_string *key;
26459
0
    zval key_tmp;
26460
26461
0
    if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
26462
0
      op1 = Z_REFVAL_P(op1);
26463
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26464
0
        result = zend_hash_find(ht, Z_STR_P(op1));
26465
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26466
0
        ZEND_VM_SMART_BRANCH(result, 0);
26467
0
      }
26468
0
    }
26469
26470
0
    SAVE_OPLINE();
26471
0
    ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
26472
0
      ZVAL_STR(&key_tmp, key);
26473
0
      if (zend_compare(op1, &key_tmp) == 0) {
26474
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26475
0
        ZEND_VM_SMART_BRANCH(1, 1);
26476
0
      }
26477
0
    } ZEND_HASH_FOREACH_END();
26478
0
  }
26479
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26480
0
  ZEND_VM_SMART_BRANCH(0, 1);
26481
0
}
26482
26483
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26484
77
{
26485
77
  zend_class_entry *ce, *scope;
26486
77
  zend_class_constant *c;
26487
77
  zval *value, *zv, *constant_zv;
26488
77
  zend_string *constant_name;
26489
77
  USE_OPLINE
26490
26491
77
  SAVE_OPLINE();
26492
26493
77
  do {
26494
77
    if (IS_VAR == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
26495
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
26496
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
26497
0
        break;
26498
0
      }
26499
0
    }
26500
77
    if (IS_VAR == IS_CONST) {
26501
0
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
26502
0
        ce = CACHED_PTR(opline->extended_value);
26503
0
      } else {
26504
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);
26505
0
        if (UNEXPECTED(ce == NULL)) {
26506
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26507
0
          FREE_OP(opline->op2_type, opline->op2.var);
26508
0
          HANDLE_EXCEPTION();
26509
0
        }
26510
0
        CACHE_PTR(opline->extended_value, ce);
26511
0
      }
26512
77
    } else if (IS_VAR == IS_UNUSED) {
26513
0
      ce = zend_fetch_class(NULL, opline->op1.num);
26514
0
      if (UNEXPECTED(ce == NULL)) {
26515
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
26516
0
        FREE_OP(opline->op2_type, opline->op2.var);
26517
0
        HANDLE_EXCEPTION();
26518
0
      }
26519
77
    } else {
26520
77
      ce = Z_CE_P(EX_VAR(opline->op1.var));
26521
77
    }
26522
77
    if (IS_VAR != IS_CONST
26523
77
      && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
26524
77
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
26525
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
26526
0
      break;
26527
0
    }
26528
26529
77
    constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
26530
77
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
26531
27
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
26532
27
      ZVAL_UNDEF(EX_VAR(opline->result.var));
26533
27
      FREE_OP(opline->op2_type, opline->op2.var);
26534
27
      HANDLE_EXCEPTION();
26535
27
    }
26536
50
    constant_name = Z_STR_P(constant_zv);
26537
    /* Magic 'class' for constant OP2 is caught at compile-time */
26538
50
    if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
26539
7
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
26540
7
      FREE_OP(opline->op2_type, opline->op2.var);
26541
7
      ZEND_VM_NEXT_OPCODE();
26542
7
    }
26543
43
    zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
26544
43
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
26545
43
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
26546
26547
43
    if (EXPECTED(zv != NULL)) {
26548
29
      c = Z_PTR_P(zv);
26549
29
      scope = EX(func)->op_array.scope;
26550
29
      if (!zend_verify_const_access(c, scope)) {
26551
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));
26552
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
26553
0
        FREE_OP(opline->op2_type, opline->op2.var);
26554
0
        HANDLE_EXCEPTION();
26555
0
      }
26556
26557
29
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
26558
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26559
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
26560
0
        FREE_OP(opline->op2_type, opline->op2.var);
26561
0
        HANDLE_EXCEPTION();
26562
0
      }
26563
26564
29
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
26565
29
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
26566
0
        if (c->ce->type == ZEND_USER_CLASS) {
26567
          /* Recursion protection only applied to user constants, GH-18463 */
26568
0
          CONST_PROTECT_RECURSION(c);
26569
0
        }
26570
0
        zend_deprecated_class_constant(c, constant_name);
26571
0
        if (c->ce->type == ZEND_USER_CLASS) {
26572
0
          CONST_UNPROTECT_RECURSION(c);
26573
0
        }
26574
26575
0
        if (EG(exception)) {
26576
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26577
0
          FREE_OP(opline->op2_type, opline->op2.var);
26578
0
          HANDLE_EXCEPTION();
26579
0
        }
26580
0
      }
26581
26582
29
      value = &c->value;
26583
      // Enums require loading of all class constants to build the backed enum table
26584
29
      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)) {
26585
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
26586
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26587
0
          FREE_OP(opline->op2_type, opline->op2.var);
26588
0
          HANDLE_EXCEPTION();
26589
0
        }
26590
0
      }
26591
29
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
26592
0
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
26593
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
26594
0
          FREE_OP(opline->op2_type, opline->op2.var);
26595
0
          HANDLE_EXCEPTION();
26596
0
        }
26597
0
      }
26598
29
      if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
26599
0
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
26600
0
      }
26601
29
    } else {
26602
14
      zend_throw_error(NULL, "Undefined constant %s::%s",
26603
14
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26604
14
      ZVAL_UNDEF(EX_VAR(opline->result.var));
26605
14
      FREE_OP(opline->op2_type, opline->op2.var);
26606
14
      HANDLE_EXCEPTION();
26607
14
    }
26608
43
  } while (0);
26609
26610
29
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
26611
26612
29
  FREE_OP(opline->op2_type, opline->op2.var);
26613
29
  ZEND_VM_NEXT_OPCODE();
26614
29
}
26615
26616
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26617
0
{
26618
0
  USE_OPLINE
26619
0
  zval *object;
26620
0
  zval *property;
26621
0
  zval *value;
26622
0
  zval *zptr;
26623
0
  void *_cache_slot[3] = {0};
26624
0
  void **cache_slot;
26625
0
  zend_property_info *prop_info;
26626
0
  zend_object *zobj;
26627
0
  zend_string *name, *tmp_name;
26628
26629
0
  SAVE_OPLINE();
26630
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26631
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26632
26633
0
  do {
26634
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26635
26636
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26637
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26638
0
        object = Z_REFVAL_P(object);
26639
0
        goto assign_op_object;
26640
0
      }
26641
0
      if (IS_VAR == IS_CV
26642
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26643
0
        ZVAL_UNDEFINED_OP1();
26644
0
      }
26645
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26646
0
      break;
26647
0
    }
26648
26649
0
assign_op_object:
26650
    /* here we are sure we are dealing with an object */
26651
0
    zobj = Z_OBJ_P(object);
26652
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26653
0
      name = Z_STR_P(property);
26654
0
    } else {
26655
0
      name = zval_try_get_tmp_string(property, &tmp_name);
26656
0
      if (UNEXPECTED(!name)) {
26657
0
        UNDEF_RESULT();
26658
0
        break;
26659
0
      }
26660
0
    }
26661
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
26662
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26663
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26664
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26665
0
          ZVAL_NULL(EX_VAR(opline->result.var));
26666
0
        }
26667
0
      } else {
26668
0
        zend_reference *ref;
26669
26670
0
        do {
26671
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
26672
0
            ref = Z_REF_P(zptr);
26673
0
            zptr = Z_REFVAL_P(zptr);
26674
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26675
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26676
0
              break;
26677
0
            }
26678
0
          }
26679
26680
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26681
0
          if (prop_info) {
26682
            /* special case for typed properties */
26683
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
26684
0
          } else {
26685
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
26686
0
          }
26687
0
        } while (0);
26688
26689
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26690
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
26691
0
        }
26692
0
      }
26693
0
    } else {
26694
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
26695
0
    }
26696
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26697
0
      zend_tmp_string_release(tmp_name);
26698
0
    }
26699
0
  } while (0);
26700
26701
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26702
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26703
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26704
  /* assign_obj has two opcodes! */
26705
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
26706
0
}
26707
26708
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
26709
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26710
325
{
26711
325
  USE_OPLINE
26712
325
  zval *var_ptr;
26713
325
  zval *value, *container, *dim;
26714
325
  HashTable *ht;
26715
26716
325
  SAVE_OPLINE();
26717
325
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26718
26719
325
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26720
98
assign_dim_op_array:
26721
98
    SEPARATE_ARRAY(container);
26722
98
    ht = Z_ARRVAL_P(container);
26723
325
assign_dim_op_new_array:
26724
325
    dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26725
325
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26726
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
26727
0
      if (UNEXPECTED(!var_ptr)) {
26728
0
        zend_cannot_add_element();
26729
0
        goto assign_dim_op_ret_null;
26730
0
      }
26731
325
    } else {
26732
325
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26733
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
26734
325
      } else {
26735
325
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
26736
325
      }
26737
325
      if (UNEXPECTED(!var_ptr)) {
26738
0
        goto assign_dim_op_ret_null;
26739
0
      }
26740
325
    }
26741
26742
325
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26743
26744
325
    do {
26745
325
      if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
26746
0
        zend_reference *ref = Z_REF_P(var_ptr);
26747
0
        var_ptr = Z_REFVAL_P(var_ptr);
26748
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26749
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26750
0
          break;
26751
0
        }
26752
0
      }
26753
325
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26754
325
    } while (0);
26755
26756
325
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26757
195
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26758
195
    }
26759
325
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26760
325
  } else {
26761
227
    if (EXPECTED(Z_ISREF_P(container))) {
26762
0
      container = Z_REFVAL_P(container);
26763
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26764
0
        goto assign_dim_op_array;
26765
0
      }
26766
0
    }
26767
26768
227
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26769
0
      zend_object *obj = Z_OBJ_P(container);
26770
26771
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26772
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
26773
0
        dim++;
26774
0
      }
26775
0
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
26776
227
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
26777
227
      uint8_t old_type;
26778
26779
227
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
26780
0
        ZVAL_UNDEFINED_OP1();
26781
0
      }
26782
227
      ht = zend_new_array(8);
26783
227
      old_type = Z_TYPE_P(container);
26784
227
      ZVAL_ARR(container, ht);
26785
227
      if (UNEXPECTED(old_type == IS_FALSE)) {
26786
0
        GC_ADDREF(ht);
26787
0
        zend_false_to_array_deprecated();
26788
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
26789
0
          zend_array_destroy(ht);
26790
0
          goto assign_dim_op_ret_null;
26791
0
        }
26792
0
      }
26793
227
      goto assign_dim_op_new_array;
26794
227
    } else {
26795
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26796
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
26797
0
assign_dim_op_ret_null:
26798
0
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26799
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26800
0
        ZVAL_NULL(EX_VAR(opline->result.var));
26801
0
      }
26802
0
    }
26803
227
  }
26804
26805
325
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26806
325
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26807
325
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
26808
325
}
26809
26810
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26811
6.85k
{
26812
6.85k
  USE_OPLINE
26813
6.85k
  zval *var_ptr;
26814
6.85k
  zval *value;
26815
26816
6.85k
  SAVE_OPLINE();
26817
6.85k
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26818
6.85k
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26819
26820
6.85k
  do {
26821
6.85k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
26822
126
      zend_reference *ref = Z_REF_P(var_ptr);
26823
126
      var_ptr = Z_REFVAL_P(var_ptr);
26824
126
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26825
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26826
0
        break;
26827
0
      }
26828
126
    }
26829
6.85k
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26830
6.85k
  } while (0);
26831
26832
6.85k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26833
6.01k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26834
6.01k
  }
26835
26836
6.85k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26837
6.85k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26838
6.85k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26839
6.85k
}
26840
26841
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26842
0
{
26843
0
  USE_OPLINE
26844
0
  zval *object;
26845
0
  zval *property;
26846
0
  zval *zptr;
26847
0
  void *_cache_slot[3] = {0};
26848
0
  void **cache_slot;
26849
0
  zend_property_info *prop_info;
26850
0
  zend_object *zobj;
26851
0
  zend_string *name, *tmp_name;
26852
26853
0
  SAVE_OPLINE();
26854
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26855
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26856
26857
0
  do {
26858
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26859
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26860
0
        object = Z_REFVAL_P(object);
26861
0
        goto pre_incdec_object;
26862
0
      }
26863
0
      if (IS_VAR == IS_CV
26864
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26865
0
        ZVAL_UNDEFINED_OP1();
26866
0
      }
26867
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26868
0
      break;
26869
0
    }
26870
26871
0
pre_incdec_object:
26872
    /* here we are sure we are dealing with an object */
26873
0
    zobj = Z_OBJ_P(object);
26874
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26875
0
      name = Z_STR_P(property);
26876
0
    } else {
26877
0
      name = zval_try_get_tmp_string(property, &tmp_name);
26878
0
      if (UNEXPECTED(!name)) {
26879
0
        UNDEF_RESULT();
26880
0
        break;
26881
0
      }
26882
0
    }
26883
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
26884
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26885
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26886
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26887
0
          ZVAL_NULL(EX_VAR(opline->result.var));
26888
0
        }
26889
0
      } else {
26890
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
26891
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26892
0
      }
26893
0
    } else {
26894
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26895
0
    }
26896
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26897
0
      zend_tmp_string_release(tmp_name);
26898
0
    }
26899
0
  } while (0);
26900
26901
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26902
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26903
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26904
0
}
26905
26906
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26907
0
{
26908
0
  USE_OPLINE
26909
0
  zval *object;
26910
0
  zval *property;
26911
0
  zval *zptr;
26912
0
  void *_cache_slot[3] = {0};
26913
0
  void **cache_slot;
26914
0
  zend_property_info *prop_info;
26915
0
  zend_object *zobj;
26916
0
  zend_string *name, *tmp_name;
26917
26918
0
  SAVE_OPLINE();
26919
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26920
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26921
26922
0
  do {
26923
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26924
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26925
0
        object = Z_REFVAL_P(object);
26926
0
        goto post_incdec_object;
26927
0
      }
26928
0
      if (IS_VAR == IS_CV
26929
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26930
0
        ZVAL_UNDEFINED_OP1();
26931
0
      }
26932
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26933
0
      break;
26934
0
    }
26935
26936
0
post_incdec_object:
26937
    /* here we are sure we are dealing with an object */
26938
0
    zobj = Z_OBJ_P(object);
26939
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26940
0
      name = Z_STR_P(property);
26941
0
    } else {
26942
0
      name = zval_try_get_tmp_string(property, &tmp_name);
26943
0
      if (UNEXPECTED(!name)) {
26944
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
26945
0
        break;
26946
0
      }
26947
0
    }
26948
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
26949
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26950
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26951
0
        ZVAL_NULL(EX_VAR(opline->result.var));
26952
0
      } else {
26953
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26954
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26955
0
      }
26956
0
    } else {
26957
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26958
0
    }
26959
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26960
0
      zend_tmp_string_release(tmp_name);
26961
0
    }
26962
0
  } while (0);
26963
26964
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26965
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26966
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26967
0
}
26968
26969
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26970
186
{
26971
186
  USE_OPLINE
26972
186
  zval *container;
26973
26974
186
  SAVE_OPLINE();
26975
186
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26976
186
  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);
26977
186
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26978
186
  if (IS_VAR == IS_VAR) {
26979
186
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26980
186
  }
26981
186
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26982
186
}
26983
26984
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26985
167
{
26986
167
  USE_OPLINE
26987
167
  zval *container;
26988
26989
167
  SAVE_OPLINE();
26990
167
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26991
167
  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);
26992
167
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26993
167
  if (IS_VAR == IS_VAR) {
26994
167
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26995
167
  }
26996
167
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26997
167
}
26998
26999
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27000
0
{
27001
#if 0
27002
  USE_OPLINE
27003
#endif
27004
27005
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
27006
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
27007
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27008
0
    }
27009
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27010
0
  } else {
27011
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27012
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27013
0
    }
27014
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27015
0
  }
27016
0
}
27017
27018
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27019
17
{
27020
17
  USE_OPLINE
27021
17
  zval *container;
27022
27023
17
  SAVE_OPLINE();
27024
17
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27025
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);
27026
17
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27027
17
  if (IS_VAR == IS_VAR) {
27028
17
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
27029
17
  }
27030
17
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27031
17
}
27032
27033
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27034
0
{
27035
0
  USE_OPLINE
27036
0
  zval *property, *container, *result;
27037
27038
0
  SAVE_OPLINE();
27039
27040
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27041
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27042
0
  result = EX_VAR(opline->result.var);
27043
0
  zend_fetch_property_address(
27044
0
    result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR),
27045
0
    (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
27046
0
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
27047
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27048
0
  if (IS_VAR == IS_VAR) {
27049
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
27050
0
  }
27051
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27052
0
}
27053
27054
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27055
0
{
27056
0
  USE_OPLINE
27057
0
  zval *property, *container, *result;
27058
27059
0
  SAVE_OPLINE();
27060
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27061
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27062
0
  result = EX_VAR(opline->result.var);
27063
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);
27064
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27065
0
  if (IS_VAR == IS_VAR) {
27066
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
27067
0
  }
27068
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27069
0
}
27070
27071
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27072
0
{
27073
#if 0
27074
  USE_OPLINE
27075
#endif
27076
27077
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
27078
    /* Behave like FETCH_OBJ_W */
27079
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
27080
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27081
0
    }
27082
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27083
0
  } else {
27084
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27085
0
  }
27086
0
}
27087
27088
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27089
0
{
27090
0
  USE_OPLINE
27091
0
  zval *container, *property, *result;
27092
27093
0
  SAVE_OPLINE();
27094
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27095
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27096
0
  result = EX_VAR(opline->result.var);
27097
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);
27098
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27099
0
  if (IS_VAR == IS_VAR) {
27100
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
27101
0
  }
27102
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27103
0
}
27104
27105
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27106
15
{
27107
15
  USE_OPLINE
27108
15
  zval *container, *dim;
27109
27110
15
  SAVE_OPLINE();
27111
15
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27112
15
  dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27113
27114
15
  if (IS_VAR == IS_VAR
27115
15
    && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
27116
15
    && UNEXPECTED(!Z_ISREF_P(container))
27117
15
  ) {
27118
0
    zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
27119
0
    zend_fetch_dimension_address_LIST_r(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
27120
15
  } else {
27121
15
    zend_fetch_dimension_address_W(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
27122
15
  }
27123
27124
15
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27125
15
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27126
15
}
27127
27128
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27129
7
{
27130
7
  USE_OPLINE
27131
7
  zval *object, *value, tmp;
27132
7
  zend_object *zobj;
27133
7
  zend_string *name, *tmp_name;
27134
7
  zend_refcounted *garbage = NULL;
27135
27136
7
  SAVE_OPLINE();
27137
7
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27138
7
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
27139
27140
7
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27141
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27142
0
      object = Z_REFVAL_P(object);
27143
0
      goto assign_object;
27144
0
    }
27145
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27146
0
    value = &EG(uninitialized_zval);
27147
0
    goto free_and_exit_assign_obj;
27148
0
  }
27149
27150
7
assign_object:
27151
7
  zobj = Z_OBJ_P(object);
27152
7
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27153
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27154
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
27155
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27156
0
      zval *property_val;
27157
0
      zend_property_info *prop_info;
27158
27159
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27160
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27161
27162
0
assign_obj_simple:
27163
0
        property_val = OBJ_PROP(zobj, prop_offset);
27164
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
27165
0
          if (prop_info != NULL) {
27166
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27167
0
            goto free_and_exit_assign_obj;
27168
0
          } else {
27169
0
fast_assign_obj:
27170
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27171
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27172
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
27173
0
            }
27174
0
            goto exit_assign_obj;
27175
0
          }
27176
0
        }
27177
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27178
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27179
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27180
0
          zobj = zend_lazy_object_init(zobj);
27181
0
          if (!zobj) {
27182
0
            value = &EG(uninitialized_zval);
27183
0
            goto free_and_exit_assign_obj;
27184
0
          }
27185
0
        }
27186
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27187
0
          rebuild_object_properties_internal(zobj);
27188
0
        }
27189
0
        if (EXPECTED(zobj->properties != NULL)) {
27190
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27191
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27192
0
              GC_DELREF(zobj->properties);
27193
0
            }
27194
0
            zobj->properties = zend_array_dup(zobj->properties);
27195
0
          }
27196
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
27197
0
          if (property_val) {
27198
0
            goto fast_assign_obj;
27199
0
          }
27200
0
        }
27201
27202
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27203
0
          if (IS_CONST == IS_CONST) {
27204
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27205
0
              Z_ADDREF_P(value);
27206
0
            }
27207
0
          } else if (IS_CONST != IS_TMP_VAR) {
27208
0
            if (Z_ISREF_P(value)) {
27209
0
              if (IS_CONST == IS_VAR) {
27210
0
                zend_reference *ref = Z_REF_P(value);
27211
0
                if (GC_DELREF(ref) == 0) {
27212
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27213
0
                  efree_size(ref, sizeof(zend_reference));
27214
0
                  value = &tmp;
27215
0
                } else {
27216
0
                  value = Z_REFVAL_P(value);
27217
0
                  Z_TRY_ADDREF_P(value);
27218
0
                }
27219
0
              } else {
27220
0
                value = Z_REFVAL_P(value);
27221
0
                Z_TRY_ADDREF_P(value);
27222
0
              }
27223
0
            } else if (IS_CONST == IS_CV) {
27224
0
              Z_TRY_ADDREF_P(value);
27225
0
            }
27226
0
          }
27227
0
          zend_hash_add_new(zobj->properties, name, value);
27228
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27229
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
27230
0
          }
27231
0
          goto exit_assign_obj;
27232
0
        }
27233
0
      } else {
27234
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27235
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27236
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
27237
0
          prop_offset = prop_info->offset;
27238
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27239
0
            prop_info = NULL;
27240
0
          }
27241
0
          goto assign_obj_simple;
27242
0
        }
27243
        /* Fall through to write_property for hooks. */
27244
0
      }
27245
0
    }
27246
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27247
7
  } else {
27248
7
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27249
7
    if (UNEXPECTED(!name)) {
27250
27251
0
      UNDEF_RESULT();
27252
0
      goto exit_assign_obj;
27253
0
    }
27254
7
  }
27255
27256
7
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
27257
0
    ZVAL_DEREF(value);
27258
0
  }
27259
27260
7
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27261
27262
7
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27263
7
    zend_tmp_string_release(tmp_name);
27264
7
  }
27265
27266
7
free_and_exit_assign_obj:
27267
7
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27268
7
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27269
7
  }
27270
27271
7
exit_assign_obj:
27272
7
  if (garbage) {
27273
0
    GC_DTOR_NO_REF(garbage);
27274
0
  }
27275
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27276
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27277
  /* assign_obj has two opcodes! */
27278
7
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27279
7
}
27280
27281
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27282
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27283
0
{
27284
0
  USE_OPLINE
27285
0
  zval *object, *value, tmp;
27286
0
  zend_object *zobj;
27287
0
  zend_string *name, *tmp_name;
27288
0
  zend_refcounted *garbage = NULL;
27289
27290
0
  SAVE_OPLINE();
27291
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27292
0
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27293
27294
0
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27295
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27296
0
      object = Z_REFVAL_P(object);
27297
0
      goto assign_object;
27298
0
    }
27299
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27300
0
    value = &EG(uninitialized_zval);
27301
0
    goto free_and_exit_assign_obj;
27302
0
  }
27303
27304
0
assign_object:
27305
0
  zobj = Z_OBJ_P(object);
27306
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27307
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27308
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
27309
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27310
0
      zval *property_val;
27311
0
      zend_property_info *prop_info;
27312
27313
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27314
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27315
27316
0
assign_obj_simple:
27317
0
        property_val = OBJ_PROP(zobj, prop_offset);
27318
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
27319
0
          if (prop_info != NULL) {
27320
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27321
0
            goto free_and_exit_assign_obj;
27322
0
          } else {
27323
0
fast_assign_obj:
27324
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27325
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27326
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
27327
0
            }
27328
0
            goto exit_assign_obj;
27329
0
          }
27330
0
        }
27331
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27332
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27333
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27334
0
          zobj = zend_lazy_object_init(zobj);
27335
0
          if (!zobj) {
27336
0
            value = &EG(uninitialized_zval);
27337
0
            goto free_and_exit_assign_obj;
27338
0
          }
27339
0
        }
27340
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27341
0
          rebuild_object_properties_internal(zobj);
27342
0
        }
27343
0
        if (EXPECTED(zobj->properties != NULL)) {
27344
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27345
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27346
0
              GC_DELREF(zobj->properties);
27347
0
            }
27348
0
            zobj->properties = zend_array_dup(zobj->properties);
27349
0
          }
27350
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
27351
0
          if (property_val) {
27352
0
            goto fast_assign_obj;
27353
0
          }
27354
0
        }
27355
27356
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27357
0
          if (IS_TMP_VAR == IS_CONST) {
27358
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27359
0
              Z_ADDREF_P(value);
27360
0
            }
27361
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
27362
0
            if (Z_ISREF_P(value)) {
27363
0
              if (IS_TMP_VAR == IS_VAR) {
27364
0
                zend_reference *ref = Z_REF_P(value);
27365
0
                if (GC_DELREF(ref) == 0) {
27366
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27367
0
                  efree_size(ref, sizeof(zend_reference));
27368
0
                  value = &tmp;
27369
0
                } else {
27370
0
                  value = Z_REFVAL_P(value);
27371
0
                  Z_TRY_ADDREF_P(value);
27372
0
                }
27373
0
              } else {
27374
0
                value = Z_REFVAL_P(value);
27375
0
                Z_TRY_ADDREF_P(value);
27376
0
              }
27377
0
            } else if (IS_TMP_VAR == IS_CV) {
27378
0
              Z_TRY_ADDREF_P(value);
27379
0
            }
27380
0
          }
27381
0
          zend_hash_add_new(zobj->properties, name, value);
27382
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27383
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
27384
0
          }
27385
0
          goto exit_assign_obj;
27386
0
        }
27387
0
      } else {
27388
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27389
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27390
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
27391
0
          prop_offset = prop_info->offset;
27392
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27393
0
            prop_info = NULL;
27394
0
          }
27395
0
          goto assign_obj_simple;
27396
0
        }
27397
        /* Fall through to write_property for hooks. */
27398
0
      }
27399
0
    }
27400
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27401
0
  } else {
27402
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27403
0
    if (UNEXPECTED(!name)) {
27404
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27405
0
      UNDEF_RESULT();
27406
0
      goto exit_assign_obj;
27407
0
    }
27408
0
  }
27409
27410
0
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27411
0
    ZVAL_DEREF(value);
27412
0
  }
27413
27414
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27415
27416
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27417
0
    zend_tmp_string_release(tmp_name);
27418
0
  }
27419
27420
0
free_and_exit_assign_obj:
27421
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27422
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27423
0
  }
27424
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27425
0
exit_assign_obj:
27426
0
  if (garbage) {
27427
0
    GC_DTOR_NO_REF(garbage);
27428
0
  }
27429
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27430
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27431
  /* assign_obj has two opcodes! */
27432
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27433
0
}
27434
27435
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27436
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27437
53
{
27438
53
  USE_OPLINE
27439
53
  zval *object, *value, tmp;
27440
53
  zend_object *zobj;
27441
53
  zend_string *name, *tmp_name;
27442
53
  zend_refcounted *garbage = NULL;
27443
27444
53
  SAVE_OPLINE();
27445
53
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27446
53
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27447
27448
53
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27449
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27450
0
      object = Z_REFVAL_P(object);
27451
0
      goto assign_object;
27452
0
    }
27453
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27454
0
    value = &EG(uninitialized_zval);
27455
0
    goto free_and_exit_assign_obj;
27456
0
  }
27457
27458
53
assign_object:
27459
53
  zobj = Z_OBJ_P(object);
27460
53
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27461
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27462
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
27463
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27464
0
      zval *property_val;
27465
0
      zend_property_info *prop_info;
27466
27467
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27468
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27469
27470
0
assign_obj_simple:
27471
0
        property_val = OBJ_PROP(zobj, prop_offset);
27472
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
27473
0
          if (prop_info != NULL) {
27474
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27475
0
            goto free_and_exit_assign_obj;
27476
0
          } else {
27477
0
fast_assign_obj:
27478
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
27479
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27480
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
27481
0
            }
27482
0
            goto exit_assign_obj;
27483
0
          }
27484
0
        }
27485
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27486
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27487
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27488
0
          zobj = zend_lazy_object_init(zobj);
27489
0
          if (!zobj) {
27490
0
            value = &EG(uninitialized_zval);
27491
0
            goto free_and_exit_assign_obj;
27492
0
          }
27493
0
        }
27494
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27495
0
          rebuild_object_properties_internal(zobj);
27496
0
        }
27497
0
        if (EXPECTED(zobj->properties != NULL)) {
27498
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27499
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27500
0
              GC_DELREF(zobj->properties);
27501
0
            }
27502
0
            zobj->properties = zend_array_dup(zobj->properties);
27503
0
          }
27504
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
27505
0
          if (property_val) {
27506
0
            goto fast_assign_obj;
27507
0
          }
27508
0
        }
27509
27510
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27511
0
          if (IS_VAR == IS_CONST) {
27512
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27513
0
              Z_ADDREF_P(value);
27514
0
            }
27515
0
          } else if (IS_VAR != IS_TMP_VAR) {
27516
0
            if (Z_ISREF_P(value)) {
27517
0
              if (IS_VAR == IS_VAR) {
27518
0
                zend_reference *ref = Z_REF_P(value);
27519
0
                if (GC_DELREF(ref) == 0) {
27520
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27521
0
                  efree_size(ref, sizeof(zend_reference));
27522
0
                  value = &tmp;
27523
0
                } else {
27524
0
                  value = Z_REFVAL_P(value);
27525
0
                  Z_TRY_ADDREF_P(value);
27526
0
                }
27527
0
              } else {
27528
0
                value = Z_REFVAL_P(value);
27529
0
                Z_TRY_ADDREF_P(value);
27530
0
              }
27531
0
            } else if (IS_VAR == IS_CV) {
27532
0
              Z_TRY_ADDREF_P(value);
27533
0
            }
27534
0
          }
27535
0
          zend_hash_add_new(zobj->properties, name, value);
27536
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27537
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
27538
0
          }
27539
0
          goto exit_assign_obj;
27540
0
        }
27541
0
      } else {
27542
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27543
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27544
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
27545
0
          prop_offset = prop_info->offset;
27546
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27547
0
            prop_info = NULL;
27548
0
          }
27549
0
          goto assign_obj_simple;
27550
0
        }
27551
        /* Fall through to write_property for hooks. */
27552
0
      }
27553
0
    }
27554
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27555
53
  } else {
27556
53
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27557
53
    if (UNEXPECTED(!name)) {
27558
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27559
0
      UNDEF_RESULT();
27560
0
      goto exit_assign_obj;
27561
0
    }
27562
53
  }
27563
27564
53
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27565
53
    ZVAL_DEREF(value);
27566
53
  }
27567
27568
53
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27569
27570
53
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27571
53
    zend_tmp_string_release(tmp_name);
27572
53
  }
27573
27574
53
free_and_exit_assign_obj:
27575
53
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27576
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27577
0
  }
27578
53
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27579
53
exit_assign_obj:
27580
53
  if (garbage) {
27581
0
    GC_DTOR_NO_REF(garbage);
27582
0
  }
27583
53
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27584
53
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27585
  /* assign_obj has two opcodes! */
27586
53
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27587
53
}
27588
27589
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27590
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27591
0
{
27592
0
  USE_OPLINE
27593
0
  zval *object, *value, tmp;
27594
0
  zend_object *zobj;
27595
0
  zend_string *name, *tmp_name;
27596
0
  zend_refcounted *garbage = NULL;
27597
27598
0
  SAVE_OPLINE();
27599
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27600
0
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
27601
27602
0
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27603
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27604
0
      object = Z_REFVAL_P(object);
27605
0
      goto assign_object;
27606
0
    }
27607
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27608
0
    value = &EG(uninitialized_zval);
27609
0
    goto free_and_exit_assign_obj;
27610
0
  }
27611
27612
0
assign_object:
27613
0
  zobj = Z_OBJ_P(object);
27614
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27615
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27616
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
27617
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27618
0
      zval *property_val;
27619
0
      zend_property_info *prop_info;
27620
27621
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27622
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27623
27624
0
assign_obj_simple:
27625
0
        property_val = OBJ_PROP(zobj, prop_offset);
27626
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
27627
0
          if (prop_info != NULL) {
27628
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27629
0
            goto free_and_exit_assign_obj;
27630
0
          } else {
27631
0
fast_assign_obj:
27632
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
27633
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27634
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
27635
0
            }
27636
0
            goto exit_assign_obj;
27637
0
          }
27638
0
        }
27639
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27640
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27641
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27642
0
          zobj = zend_lazy_object_init(zobj);
27643
0
          if (!zobj) {
27644
0
            value = &EG(uninitialized_zval);
27645
0
            goto free_and_exit_assign_obj;
27646
0
          }
27647
0
        }
27648
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27649
0
          rebuild_object_properties_internal(zobj);
27650
0
        }
27651
0
        if (EXPECTED(zobj->properties != NULL)) {
27652
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27653
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27654
0
              GC_DELREF(zobj->properties);
27655
0
            }
27656
0
            zobj->properties = zend_array_dup(zobj->properties);
27657
0
          }
27658
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
27659
0
          if (property_val) {
27660
0
            goto fast_assign_obj;
27661
0
          }
27662
0
        }
27663
27664
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27665
0
          if (IS_CV == IS_CONST) {
27666
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27667
0
              Z_ADDREF_P(value);
27668
0
            }
27669
0
          } else if (IS_CV != IS_TMP_VAR) {
27670
0
            if (Z_ISREF_P(value)) {
27671
0
              if (IS_CV == IS_VAR) {
27672
0
                zend_reference *ref = Z_REF_P(value);
27673
0
                if (GC_DELREF(ref) == 0) {
27674
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27675
0
                  efree_size(ref, sizeof(zend_reference));
27676
0
                  value = &tmp;
27677
0
                } else {
27678
0
                  value = Z_REFVAL_P(value);
27679
0
                  Z_TRY_ADDREF_P(value);
27680
0
                }
27681
0
              } else {
27682
0
                value = Z_REFVAL_P(value);
27683
0
                Z_TRY_ADDREF_P(value);
27684
0
              }
27685
0
            } else if (IS_CV == IS_CV) {
27686
0
              Z_TRY_ADDREF_P(value);
27687
0
            }
27688
0
          }
27689
0
          zend_hash_add_new(zobj->properties, name, value);
27690
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27691
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
27692
0
          }
27693
0
          goto exit_assign_obj;
27694
0
        }
27695
0
      } else {
27696
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27697
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27698
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
27699
0
          prop_offset = prop_info->offset;
27700
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27701
0
            prop_info = NULL;
27702
0
          }
27703
0
          goto assign_obj_simple;
27704
0
        }
27705
        /* Fall through to write_property for hooks. */
27706
0
      }
27707
0
    }
27708
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27709
0
  } else {
27710
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27711
0
    if (UNEXPECTED(!name)) {
27712
27713
0
      UNDEF_RESULT();
27714
0
      goto exit_assign_obj;
27715
0
    }
27716
0
  }
27717
27718
0
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
27719
0
    ZVAL_DEREF(value);
27720
0
  }
27721
27722
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27723
27724
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27725
0
    zend_tmp_string_release(tmp_name);
27726
0
  }
27727
27728
0
free_and_exit_assign_obj:
27729
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27730
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27731
0
  }
27732
27733
0
exit_assign_obj:
27734
0
  if (garbage) {
27735
0
    GC_DTOR_NO_REF(garbage);
27736
0
  }
27737
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27738
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27739
  /* assign_obj has two opcodes! */
27740
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27741
0
}
27742
27743
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27744
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27745
70
{
27746
70
  USE_OPLINE
27747
70
  zval *object_ptr, *orig_object_ptr;
27748
70
  zval *value;
27749
70
  zval *variable_ptr;
27750
70
  zval *dim;
27751
70
  zend_refcounted *garbage = NULL;
27752
27753
70
  SAVE_OPLINE();
27754
70
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27755
27756
70
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27757
70
try_assign_dim_array:
27758
70
    SEPARATE_ARRAY(object_ptr);
27759
70
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27760
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
27761
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27762
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
27763
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27764
0
          GC_ADDREF(ht);
27765
0
        }
27766
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27767
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27768
0
          zend_array_destroy(ht);
27769
0
          goto assign_dim_error;
27770
0
        }
27771
0
      }
27772
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
27773
0
        ZVAL_DEREF(value);
27774
0
      }
27775
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27776
0
      if (UNEXPECTED(value == NULL)) {
27777
0
        zend_cannot_add_element();
27778
0
        goto assign_dim_error;
27779
0
      } else if (IS_CONST == IS_CV) {
27780
0
        if (Z_REFCOUNTED_P(value)) {
27781
0
          Z_ADDREF_P(value);
27782
0
        }
27783
0
      } else if (IS_CONST == IS_VAR) {
27784
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
27785
0
        if (Z_ISREF_P(free_op_data)) {
27786
0
          if (Z_REFCOUNTED_P(value)) {
27787
0
            Z_ADDREF_P(value);
27788
0
          }
27789
0
          zval_ptr_dtor_nogc(free_op_data);
27790
0
        }
27791
0
      } else if (IS_CONST == IS_CONST) {
27792
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27793
0
          Z_ADDREF_P(value);
27794
0
        }
27795
0
      }
27796
70
    } else {
27797
70
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27798
70
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27799
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27800
70
      } else {
27801
70
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27802
70
      }
27803
70
      if (UNEXPECTED(variable_ptr == NULL)) {
27804
3
        goto assign_dim_error;
27805
3
      }
27806
67
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
27807
67
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27808
67
    }
27809
67
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27810
59
      ZVAL_COPY(EX_VAR(opline->result.var), value);
27811
59
    }
27812
67
    if (garbage) {
27813
0
      GC_DTOR_NO_REF(garbage);
27814
0
    }
27815
67
  } else {
27816
44
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
27817
5
      object_ptr = Z_REFVAL_P(object_ptr);
27818
5
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27819
0
        goto try_assign_dim_array;
27820
0
      }
27821
5
    }
27822
44
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27823
0
      zend_object *obj = Z_OBJ_P(object_ptr);
27824
27825
0
      GC_ADDREF(obj);
27826
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27827
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27828
0
        dim = ZVAL_UNDEFINED_OP2();
27829
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27830
0
        dim++;
27831
0
      }
27832
27833
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
27834
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27835
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27836
0
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
27837
0
        ZVAL_DEREF(value);
27838
0
      }
27839
27840
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27841
27842
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27843
0
        zend_objects_store_del(obj);
27844
0
      }
27845
44
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27846
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27847
0
        zend_use_new_element_for_string();
27848
27849
0
        UNDEF_RESULT();
27850
0
      } else {
27851
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27852
0
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
27853
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27854
27855
0
      }
27856
44
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27857
44
      if (Z_ISREF_P(orig_object_ptr)
27858
44
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27859
44
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27860
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27861
27862
0
        UNDEF_RESULT();
27863
44
      } else {
27864
44
        HashTable *ht = zend_new_array(8);
27865
44
        uint8_t old_type = Z_TYPE_P(object_ptr);
27866
27867
44
        ZVAL_ARR(object_ptr, ht);
27868
44
        if (UNEXPECTED(old_type == IS_FALSE)) {
27869
0
          GC_ADDREF(ht);
27870
0
          zend_false_to_array_deprecated();
27871
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27872
0
            zend_array_destroy(ht);
27873
0
            goto assign_dim_error;
27874
0
          }
27875
0
        }
27876
44
        goto try_assign_dim_array;
27877
44
      }
27878
44
    } else {
27879
0
      zend_use_scalar_as_array();
27880
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27881
3
assign_dim_error:
27882
27883
3
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27884
3
        ZVAL_NULL(EX_VAR(opline->result.var));
27885
3
      }
27886
3
    }
27887
44
  }
27888
70
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27889
70
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27890
70
  }
27891
70
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27892
  /* assign_dim has two opcodes! */
27893
70
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
27894
70
}
27895
27896
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27897
197
{
27898
197
  USE_OPLINE
27899
197
  zval *object_ptr, *orig_object_ptr;
27900
197
  zval *value;
27901
197
  zval *variable_ptr;
27902
197
  zval *dim;
27903
197
  zend_refcounted *garbage = NULL;
27904
27905
197
  SAVE_OPLINE();
27906
197
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27907
27908
197
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27909
197
try_assign_dim_array:
27910
197
    SEPARATE_ARRAY(object_ptr);
27911
197
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27912
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27913
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27914
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
27915
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27916
0
          GC_ADDREF(ht);
27917
0
        }
27918
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27919
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27920
0
          zend_array_destroy(ht);
27921
0
          goto assign_dim_error;
27922
0
        }
27923
0
      }
27924
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27925
0
        ZVAL_DEREF(value);
27926
0
      }
27927
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27928
0
      if (UNEXPECTED(value == NULL)) {
27929
0
        zend_cannot_add_element();
27930
0
        goto assign_dim_error;
27931
0
      } else if (IS_TMP_VAR == IS_CV) {
27932
0
        if (Z_REFCOUNTED_P(value)) {
27933
0
          Z_ADDREF_P(value);
27934
0
        }
27935
0
      } else if (IS_TMP_VAR == IS_VAR) {
27936
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
27937
0
        if (Z_ISREF_P(free_op_data)) {
27938
0
          if (Z_REFCOUNTED_P(value)) {
27939
0
            Z_ADDREF_P(value);
27940
0
          }
27941
0
          zval_ptr_dtor_nogc(free_op_data);
27942
0
        }
27943
0
      } else if (IS_TMP_VAR == IS_CONST) {
27944
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27945
0
          Z_ADDREF_P(value);
27946
0
        }
27947
0
      }
27948
197
    } else {
27949
197
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27950
197
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27951
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27952
197
      } else {
27953
197
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27954
197
      }
27955
197
      if (UNEXPECTED(variable_ptr == NULL)) {
27956
0
        goto assign_dim_error;
27957
0
      }
27958
197
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27959
197
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27960
197
    }
27961
197
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27962
157
      ZVAL_COPY(EX_VAR(opline->result.var), value);
27963
157
    }
27964
197
    if (garbage) {
27965
5
      GC_DTOR_NO_REF(garbage);
27966
5
    }
27967
197
  } else {
27968
28
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
27969
0
      object_ptr = Z_REFVAL_P(object_ptr);
27970
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27971
0
        goto try_assign_dim_array;
27972
0
      }
27973
0
    }
27974
28
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27975
0
      zend_object *obj = Z_OBJ_P(object_ptr);
27976
27977
0
      GC_ADDREF(obj);
27978
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27979
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27980
0
        dim = ZVAL_UNDEFINED_OP2();
27981
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27982
0
        dim++;
27983
0
      }
27984
27985
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27986
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27987
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27988
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
27989
0
        ZVAL_DEREF(value);
27990
0
      }
27991
27992
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27993
27994
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27995
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27996
0
        zend_objects_store_del(obj);
27997
0
      }
27998
28
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27999
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28000
0
        zend_use_new_element_for_string();
28001
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28002
0
        UNDEF_RESULT();
28003
0
      } else {
28004
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28005
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28006
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28007
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28008
0
      }
28009
28
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28010
28
      if (Z_ISREF_P(orig_object_ptr)
28011
28
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28012
28
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28013
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28014
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28015
0
        UNDEF_RESULT();
28016
28
      } else {
28017
28
        HashTable *ht = zend_new_array(8);
28018
28
        uint8_t old_type = Z_TYPE_P(object_ptr);
28019
28020
28
        ZVAL_ARR(object_ptr, ht);
28021
28
        if (UNEXPECTED(old_type == IS_FALSE)) {
28022
0
          GC_ADDREF(ht);
28023
0
          zend_false_to_array_deprecated();
28024
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28025
0
            zend_array_destroy(ht);
28026
0
            goto assign_dim_error;
28027
0
          }
28028
0
        }
28029
28
        goto try_assign_dim_array;
28030
28
      }
28031
28
    } else {
28032
0
      zend_use_scalar_as_array();
28033
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28034
0
assign_dim_error:
28035
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28036
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28037
0
        ZVAL_NULL(EX_VAR(opline->result.var));
28038
0
      }
28039
0
    }
28040
28
  }
28041
197
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28042
197
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28043
197
  }
28044
197
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28045
  /* assign_dim has two opcodes! */
28046
197
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28047
197
}
28048
28049
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28050
0
{
28051
0
  USE_OPLINE
28052
0
  zval *object_ptr, *orig_object_ptr;
28053
0
  zval *value;
28054
0
  zval *variable_ptr;
28055
0
  zval *dim;
28056
0
  zend_refcounted *garbage = NULL;
28057
28058
0
  SAVE_OPLINE();
28059
0
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28060
28061
0
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28062
0
try_assign_dim_array:
28063
0
    SEPARATE_ARRAY(object_ptr);
28064
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28065
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28066
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28067
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
28068
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28069
0
          GC_ADDREF(ht);
28070
0
        }
28071
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28072
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28073
0
          zend_array_destroy(ht);
28074
0
          goto assign_dim_error;
28075
0
        }
28076
0
      }
28077
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28078
0
        ZVAL_DEREF(value);
28079
0
      }
28080
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28081
0
      if (UNEXPECTED(value == NULL)) {
28082
0
        zend_cannot_add_element();
28083
0
        goto assign_dim_error;
28084
0
      } else if (IS_VAR == IS_CV) {
28085
0
        if (Z_REFCOUNTED_P(value)) {
28086
0
          Z_ADDREF_P(value);
28087
0
        }
28088
0
      } else if (IS_VAR == IS_VAR) {
28089
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
28090
0
        if (Z_ISREF_P(free_op_data)) {
28091
0
          if (Z_REFCOUNTED_P(value)) {
28092
0
            Z_ADDREF_P(value);
28093
0
          }
28094
0
          zval_ptr_dtor_nogc(free_op_data);
28095
0
        }
28096
0
      } else if (IS_VAR == IS_CONST) {
28097
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28098
0
          Z_ADDREF_P(value);
28099
0
        }
28100
0
      }
28101
0
    } else {
28102
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28103
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28104
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28105
0
      } else {
28106
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28107
0
      }
28108
0
      if (UNEXPECTED(variable_ptr == NULL)) {
28109
0
        goto assign_dim_error;
28110
0
      }
28111
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28112
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28113
0
    }
28114
0
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28115
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
28116
0
    }
28117
0
    if (garbage) {
28118
0
      GC_DTOR_NO_REF(garbage);
28119
0
    }
28120
0
  } else {
28121
0
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
28122
0
      object_ptr = Z_REFVAL_P(object_ptr);
28123
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28124
0
        goto try_assign_dim_array;
28125
0
      }
28126
0
    }
28127
0
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28128
0
      zend_object *obj = Z_OBJ_P(object_ptr);
28129
28130
0
      GC_ADDREF(obj);
28131
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28132
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28133
0
        dim = ZVAL_UNDEFINED_OP2();
28134
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28135
0
        dim++;
28136
0
      }
28137
28138
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28139
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28140
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28141
0
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
28142
0
        ZVAL_DEREF(value);
28143
0
      }
28144
28145
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28146
28147
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28148
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28149
0
        zend_objects_store_del(obj);
28150
0
      }
28151
0
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28152
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28153
0
        zend_use_new_element_for_string();
28154
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28155
0
        UNDEF_RESULT();
28156
0
      } else {
28157
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28158
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28159
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28160
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28161
0
      }
28162
0
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28163
0
      if (Z_ISREF_P(orig_object_ptr)
28164
0
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28165
0
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28166
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28167
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28168
0
        UNDEF_RESULT();
28169
0
      } else {
28170
0
        HashTable *ht = zend_new_array(8);
28171
0
        uint8_t old_type = Z_TYPE_P(object_ptr);
28172
28173
0
        ZVAL_ARR(object_ptr, ht);
28174
0
        if (UNEXPECTED(old_type == IS_FALSE)) {
28175
0
          GC_ADDREF(ht);
28176
0
          zend_false_to_array_deprecated();
28177
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28178
0
            zend_array_destroy(ht);
28179
0
            goto assign_dim_error;
28180
0
          }
28181
0
        }
28182
0
        goto try_assign_dim_array;
28183
0
      }
28184
0
    } else {
28185
0
      zend_use_scalar_as_array();
28186
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28187
0
assign_dim_error:
28188
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28189
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28190
0
        ZVAL_NULL(EX_VAR(opline->result.var));
28191
0
      }
28192
0
    }
28193
0
  }
28194
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28195
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28196
0
  }
28197
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28198
  /* assign_dim has two opcodes! */
28199
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28200
0
}
28201
28202
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28203
5
{
28204
5
  USE_OPLINE
28205
5
  zval *object_ptr, *orig_object_ptr;
28206
5
  zval *value;
28207
5
  zval *variable_ptr;
28208
5
  zval *dim;
28209
5
  zend_refcounted *garbage = NULL;
28210
28211
5
  SAVE_OPLINE();
28212
5
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28213
28214
5
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28215
0
try_assign_dim_array:
28216
0
    SEPARATE_ARRAY(object_ptr);
28217
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28218
0
      value = EX_VAR((opline+1)->op1.var);
28219
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28220
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
28221
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28222
0
          GC_ADDREF(ht);
28223
0
        }
28224
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28225
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28226
0
          zend_array_destroy(ht);
28227
0
          goto assign_dim_error;
28228
0
        }
28229
0
      }
28230
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
28231
0
        ZVAL_DEREF(value);
28232
0
      }
28233
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28234
0
      if (UNEXPECTED(value == NULL)) {
28235
0
        zend_cannot_add_element();
28236
0
        goto assign_dim_error;
28237
0
      } else if (IS_CV == IS_CV) {
28238
0
        if (Z_REFCOUNTED_P(value)) {
28239
0
          Z_ADDREF_P(value);
28240
0
        }
28241
0
      } else if (IS_CV == IS_VAR) {
28242
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
28243
0
        if (Z_ISREF_P(free_op_data)) {
28244
0
          if (Z_REFCOUNTED_P(value)) {
28245
0
            Z_ADDREF_P(value);
28246
0
          }
28247
0
          zval_ptr_dtor_nogc(free_op_data);
28248
0
        }
28249
0
      } else if (IS_CV == IS_CONST) {
28250
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28251
0
          Z_ADDREF_P(value);
28252
0
        }
28253
0
      }
28254
0
    } else {
28255
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28256
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28257
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28258
0
      } else {
28259
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28260
0
      }
28261
0
      if (UNEXPECTED(variable_ptr == NULL)) {
28262
0
        goto assign_dim_error;
28263
0
      }
28264
0
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
28265
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
28266
0
    }
28267
0
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28268
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
28269
0
    }
28270
0
    if (garbage) {
28271
0
      GC_DTOR_NO_REF(garbage);
28272
0
    }
28273
5
  } else {
28274
5
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
28275
0
      object_ptr = Z_REFVAL_P(object_ptr);
28276
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28277
0
        goto try_assign_dim_array;
28278
0
      }
28279
0
    }
28280
5
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28281
5
      zend_object *obj = Z_OBJ_P(object_ptr);
28282
28283
5
      GC_ADDREF(obj);
28284
5
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28285
5
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28286
0
        dim = ZVAL_UNDEFINED_OP2();
28287
5
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28288
0
        dim++;
28289
0
      }
28290
28291
5
      value = EX_VAR((opline+1)->op1.var);
28292
5
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28293
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28294
5
      } else if (IS_CV & (IS_CV|IS_VAR)) {
28295
5
        ZVAL_DEREF(value);
28296
5
      }
28297
28298
5
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28299
28300
5
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28301
0
        zend_objects_store_del(obj);
28302
0
      }
28303
5
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28304
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28305
0
        zend_use_new_element_for_string();
28306
28307
0
        UNDEF_RESULT();
28308
0
      } else {
28309
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28310
0
        value = EX_VAR((opline+1)->op1.var);
28311
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28312
28313
0
      }
28314
0
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28315
0
      if (Z_ISREF_P(orig_object_ptr)
28316
0
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28317
0
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28318
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28319
28320
0
        UNDEF_RESULT();
28321
0
      } else {
28322
0
        HashTable *ht = zend_new_array(8);
28323
0
        uint8_t old_type = Z_TYPE_P(object_ptr);
28324
28325
0
        ZVAL_ARR(object_ptr, ht);
28326
0
        if (UNEXPECTED(old_type == IS_FALSE)) {
28327
0
          GC_ADDREF(ht);
28328
0
          zend_false_to_array_deprecated();
28329
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28330
0
            zend_array_destroy(ht);
28331
0
            goto assign_dim_error;
28332
0
          }
28333
0
        }
28334
0
        goto try_assign_dim_array;
28335
0
      }
28336
0
    } else {
28337
0
      zend_use_scalar_as_array();
28338
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28339
0
assign_dim_error:
28340
28341
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28342
0
        ZVAL_NULL(EX_VAR(opline->result.var));
28343
0
      }
28344
0
    }
28345
5
  }
28346
5
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28347
5
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28348
5
  }
28349
5
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28350
  /* assign_dim has two opcodes! */
28351
5
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28352
5
}
28353
28354
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28355
0
{
28356
0
  USE_OPLINE
28357
0
  zval *property, *container, *value_ptr;
28358
28359
0
  SAVE_OPLINE();
28360
28361
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28362
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28363
28364
0
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28365
28366
0
  if (1) {
28367
0
    if (IS_VAR == IS_UNUSED) {
28368
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28369
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28370
0
      } else {
28371
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28372
0
      }
28373
0
    } else {
28374
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28375
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28376
0
      } else {
28377
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28378
0
      }
28379
0
    }
28380
0
  } else {
28381
0
    zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
28382
0
  }
28383
28384
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28385
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28386
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28387
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28388
0
}
28389
28390
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
28391
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28392
0
{
28393
0
  USE_OPLINE
28394
0
  zval *property, *container, *value_ptr;
28395
28396
0
  SAVE_OPLINE();
28397
28398
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28399
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28400
28401
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
28402
28403
0
  if (1) {
28404
0
    if (IS_VAR == IS_UNUSED) {
28405
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28406
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28407
0
      } else {
28408
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28409
0
      }
28410
0
    } else {
28411
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28412
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28413
0
      } else {
28414
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28415
0
      }
28416
0
    }
28417
0
  } else {
28418
0
    zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
28419
0
  }
28420
28421
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28422
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28423
28424
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
28425
0
}
28426
28427
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
28428
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28429
12
{
28430
12
  USE_OPLINE
28431
12
  zval *function_name;
28432
12
  zend_class_entry *ce;
28433
12
  uint32_t call_info;
28434
12
  zend_function *fbc;
28435
12
  zend_execute_data *call;
28436
28437
12
  SAVE_OPLINE();
28438
28439
12
  if (IS_VAR == IS_CONST) {
28440
    /* no function found. try a static method in class */
28441
0
    ce = CACHED_PTR(opline->result.num);
28442
0
    if (UNEXPECTED(ce == NULL)) {
28443
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);
28444
0
      if (UNEXPECTED(ce == NULL)) {
28445
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28446
0
        HANDLE_EXCEPTION();
28447
0
      }
28448
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28449
0
        CACHE_PTR(opline->result.num, ce);
28450
0
      }
28451
0
    }
28452
12
  } else if (IS_VAR == IS_UNUSED) {
28453
0
    ce = zend_fetch_class(NULL, opline->op1.num);
28454
0
    if (UNEXPECTED(ce == NULL)) {
28455
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28456
0
      HANDLE_EXCEPTION();
28457
0
    }
28458
12
  } else {
28459
12
    ce = Z_CE_P(EX_VAR(opline->op1.var));
28460
12
  }
28461
28462
12
  if (IS_VAR == IS_CONST &&
28463
12
      (IS_TMP_VAR|IS_VAR) == IS_CONST &&
28464
12
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
28465
    /* nothing to do */
28466
12
  } else if (IS_VAR != IS_CONST &&
28467
12
             (IS_TMP_VAR|IS_VAR) == IS_CONST &&
28468
12
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
28469
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
28470
12
  } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28471
12
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28472
12
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28473
12
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
28474
0
        do {
28475
0
          if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
28476
0
            function_name = Z_REFVAL_P(function_name);
28477
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
28478
0
              break;
28479
0
            }
28480
0
          } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
28481
0
            ZVAL_UNDEFINED_OP2();
28482
0
            if (UNEXPECTED(EG(exception) != NULL)) {
28483
0
              HANDLE_EXCEPTION();
28484
0
            }
28485
0
          }
28486
0
          zend_throw_error(NULL, "Method name must be a string");
28487
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28488
0
          HANDLE_EXCEPTION();
28489
0
        } while (0);
28490
0
      }
28491
12
    }
28492
28493
12
    if (ce->get_static_method) {
28494
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
28495
12
    } else {
28496
12
      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));
28497
12
    }
28498
12
    if (UNEXPECTED(fbc == NULL)) {
28499
0
      if (EXPECTED(!EG(exception))) {
28500
0
        zend_undefined_method(ce, Z_STR_P(function_name));
28501
0
      }
28502
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28503
0
      HANDLE_EXCEPTION();
28504
0
    }
28505
12
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
28506
12
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
28507
12
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
28508
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
28509
0
    }
28510
12
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
28511
0
      init_func_run_time_cache(&fbc->op_array);
28512
0
    }
28513
12
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28514
12
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28515
12
    }
28516
12
  } else {
28517
0
    if (UNEXPECTED(ce->constructor == NULL)) {
28518
0
      zend_throw_error(NULL, "Cannot call constructor");
28519
0
      HANDLE_EXCEPTION();
28520
0
    }
28521
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)) {
28522
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
28523
0
      HANDLE_EXCEPTION();
28524
0
    }
28525
0
    fbc = ce->constructor;
28526
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
28527
0
      init_func_run_time_cache(&fbc->op_array);
28528
0
    }
28529
0
  }
28530
28531
12
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
28532
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
28533
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
28534
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
28535
0
    } else {
28536
0
      zend_non_static_method_call(fbc);
28537
0
      HANDLE_EXCEPTION();
28538
0
    }
28539
12
  } else {
28540
    /* previous opcode is ZEND_FETCH_CLASS */
28541
12
    if (IS_VAR == IS_UNUSED
28542
12
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
28543
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
28544
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
28545
0
        ce = Z_OBJCE(EX(This));
28546
0
      } else {
28547
0
        ce = Z_CE(EX(This));
28548
0
      }
28549
0
    }
28550
12
    call_info = ZEND_CALL_NESTED_FUNCTION;
28551
12
  }
28552
28553
12
  call = zend_vm_stack_push_call_frame(call_info,
28554
12
    fbc, opline->extended_value, ce);
28555
12
  call->prev_execute_data = EX(call);
28556
12
  EX(call) = call;
28557
28558
12
  ZEND_VM_NEXT_OPCODE();
28559
12
}
28560
28561
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28562
0
{
28563
0
  USE_OPLINE
28564
0
  zval *expr_ptr, new_expr;
28565
28566
0
  SAVE_OPLINE();
28567
0
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
28568
0
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
28569
0
    expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28570
0
    if (Z_ISREF_P(expr_ptr)) {
28571
0
      Z_ADDREF_P(expr_ptr);
28572
0
    } else {
28573
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
28574
0
    }
28575
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28576
0
  } else {
28577
0
    expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28578
0
    if (IS_VAR == IS_TMP_VAR) {
28579
      /* pass */
28580
0
    } else if (IS_VAR == IS_CONST) {
28581
0
      Z_TRY_ADDREF_P(expr_ptr);
28582
0
    } else if (IS_VAR == IS_CV) {
28583
0
      ZVAL_DEREF(expr_ptr);
28584
0
      Z_TRY_ADDREF_P(expr_ptr);
28585
0
    } else /* if (IS_VAR == IS_VAR) */ {
28586
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
28587
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
28588
28589
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
28590
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
28591
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
28592
0
          expr_ptr = &new_expr;
28593
0
          efree_size(ref, sizeof(zend_reference));
28594
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
28595
0
          Z_ADDREF_P(expr_ptr);
28596
0
        }
28597
0
      }
28598
0
    }
28599
0
  }
28600
28601
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28602
0
    zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28603
0
    zend_string *str;
28604
0
    zend_ulong hval;
28605
28606
0
add_again:
28607
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
28608
0
      str = Z_STR_P(offset);
28609
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28610
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
28611
0
          goto num_index;
28612
0
        }
28613
0
      }
28614
0
str_index:
28615
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
28616
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
28617
0
      hval = Z_LVAL_P(offset);
28618
0
num_index:
28619
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
28620
0
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
28621
0
      offset = Z_REFVAL_P(offset);
28622
0
      goto add_again;
28623
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
28624
0
      str = ZSTR_EMPTY_ALLOC();
28625
0
      goto str_index;
28626
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
28627
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
28628
0
      goto num_index;
28629
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
28630
0
      hval = 0;
28631
0
      goto num_index;
28632
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
28633
0
      hval = 1;
28634
0
      goto num_index;
28635
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
28636
0
      zend_use_resource_as_offset(offset);
28637
0
      hval = Z_RES_HANDLE_P(offset);
28638
0
      goto num_index;
28639
0
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
28640
0
      ZVAL_UNDEFINED_OP2();
28641
0
      str = ZSTR_EMPTY_ALLOC();
28642
0
      goto str_index;
28643
0
    } else {
28644
0
      zend_illegal_array_offset_access(offset);
28645
0
      zval_ptr_dtor_nogc(expr_ptr);
28646
0
    }
28647
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28648
0
  } else {
28649
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
28650
0
      zend_cannot_add_element();
28651
0
      zval_ptr_dtor_nogc(expr_ptr);
28652
0
    }
28653
0
  }
28654
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28655
0
}
28656
28657
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28658
0
{
28659
0
  zval *array;
28660
0
  uint32_t size;
28661
0
  USE_OPLINE
28662
28663
0
  SAVE_OPLINE();
28664
0
  array = EX_VAR(opline->result.var);
28665
0
  if (IS_VAR != IS_UNUSED) {
28666
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
28667
0
    ZVAL_ARR(array, zend_new_array(size));
28668
    /* Explicitly initialize array as not-packed if flag is set */
28669
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
28670
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
28671
0
    }
28672
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28673
0
  } else {
28674
0
    ZVAL_ARR(array, zend_new_array(0));
28675
0
    ZEND_VM_NEXT_OPCODE();
28676
0
  }
28677
0
}
28678
28679
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28680
50
{
28681
50
  USE_OPLINE
28682
50
  zval *container;
28683
50
  zval *offset;
28684
50
  zend_ulong hval;
28685
50
  zend_string *key;
28686
28687
50
  SAVE_OPLINE();
28688
50
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28689
50
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28690
28691
50
  do {
28692
50
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28693
38
      HashTable *ht;
28694
28695
38
unset_dim_array:
28696
38
      SEPARATE_ARRAY(container);
28697
38
      ht = Z_ARRVAL_P(container);
28698
38
offset_again:
28699
38
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
28700
0
        key = Z_STR_P(offset);
28701
0
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28702
0
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
28703
0
            goto num_index_dim;
28704
0
          }
28705
0
        }
28706
0
str_index_dim:
28707
0
        ZEND_ASSERT(ht != &EG(symbol_table));
28708
0
        zend_hash_del(ht, key);
28709
38
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
28710
38
        hval = Z_LVAL_P(offset);
28711
38
num_index_dim:
28712
38
        zend_hash_index_del(ht, hval);
28713
38
      } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
28714
0
        offset = Z_REFVAL_P(offset);
28715
0
        goto offset_again;
28716
0
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
28717
0
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
28718
0
        goto num_index_dim;
28719
0
      } else if (Z_TYPE_P(offset) == IS_NULL) {
28720
0
        key = ZSTR_EMPTY_ALLOC();
28721
0
        goto str_index_dim;
28722
0
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
28723
0
        hval = 0;
28724
0
        goto num_index_dim;
28725
0
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
28726
0
        hval = 1;
28727
0
        goto num_index_dim;
28728
0
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
28729
0
        zend_use_resource_as_offset(offset);
28730
0
        hval = Z_RES_HANDLE_P(offset);
28731
0
        goto num_index_dim;
28732
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
28733
0
        ZVAL_UNDEFINED_OP2();
28734
0
        key = ZSTR_EMPTY_ALLOC();
28735
0
        goto str_index_dim;
28736
0
      } else {
28737
0
        zend_illegal_array_offset_unset(offset);
28738
0
      }
28739
38
      break;
28740
38
    } else if (Z_ISREF_P(container)) {
28741
0
      container = Z_REFVAL_P(container);
28742
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28743
0
        goto unset_dim_array;
28744
0
      }
28745
0
    }
28746
12
    if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
28747
0
      container = ZVAL_UNDEFINED_OP1();
28748
0
    }
28749
12
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
28750
0
      offset = ZVAL_UNDEFINED_OP2();
28751
0
    }
28752
12
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
28753
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
28754
0
        offset++;
28755
0
      }
28756
0
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
28757
12
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
28758
0
      zend_throw_error(NULL, "Cannot unset string offsets");
28759
12
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
28760
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
28761
12
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
28762
0
      zend_false_to_array_deprecated();
28763
0
    }
28764
12
  } while (0);
28765
28766
50
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28767
50
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28768
50
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28769
50
}
28770
28771
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28772
0
{
28773
0
  USE_OPLINE
28774
0
  zval *container;
28775
0
  zval *offset;
28776
0
  zend_string *name, *tmp_name;
28777
28778
0
  SAVE_OPLINE();
28779
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28780
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28781
28782
0
  do {
28783
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
28784
0
      if (Z_ISREF_P(container)) {
28785
0
        container = Z_REFVAL_P(container);
28786
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
28787
0
          if (IS_VAR == IS_CV
28788
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
28789
0
            ZVAL_UNDEFINED_OP1();
28790
0
          }
28791
0
          break;
28792
0
        }
28793
0
      } else {
28794
0
        break;
28795
0
      }
28796
0
    }
28797
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28798
0
      name = Z_STR_P(offset);
28799
0
    } else {
28800
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
28801
0
      if (UNEXPECTED(!name)) {
28802
0
        break;
28803
0
      }
28804
0
    }
28805
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));
28806
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28807
0
      zend_tmp_string_release(tmp_name);
28808
0
    }
28809
0
  } while (0);
28810
28811
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28812
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28813
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28814
0
}
28815
28816
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28817
0
{
28818
0
  USE_OPLINE
28819
28820
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
28821
28822
0
  SAVE_OPLINE();
28823
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
28824
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28825
0
  }
28826
28827
  /* Destroy the previously yielded value */
28828
0
  zval_ptr_dtor(&generator->value);
28829
28830
  /* Destroy the previously yielded key */
28831
0
  zval_ptr_dtor(&generator->key);
28832
28833
  /* Set the new yielded value */
28834
0
  if (IS_VAR != IS_UNUSED) {
28835
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
28836
      /* Constants and temporary variables aren't yieldable by reference,
28837
       * but we still allow them with a notice. */
28838
0
      if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
28839
0
        zval *value;
28840
28841
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28842
28843
0
        value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28844
0
        ZVAL_COPY_VALUE(&generator->value, value);
28845
0
        if (IS_VAR == IS_CONST) {
28846
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28847
0
            Z_ADDREF(generator->value);
28848
0
          }
28849
0
        }
28850
0
      } else {
28851
0
        zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28852
28853
        /* If a function call result is yielded and the function did
28854
         * not return by reference we throw a notice. */
28855
0
        do {
28856
0
          if (IS_VAR == IS_VAR) {
28857
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
28858
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
28859
0
             && !Z_ISREF_P(value_ptr)) {
28860
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28861
0
              ZVAL_COPY(&generator->value, value_ptr);
28862
0
              break;
28863
0
            }
28864
0
          }
28865
0
          if (Z_ISREF_P(value_ptr)) {
28866
0
            Z_ADDREF_P(value_ptr);
28867
0
          } else {
28868
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
28869
0
          }
28870
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
28871
0
        } while (0);
28872
28873
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28874
0
      }
28875
0
    } else {
28876
0
      zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28877
28878
      /* Consts, temporary variables and references need copying */
28879
0
      if (IS_VAR == IS_CONST) {
28880
0
        ZVAL_COPY_VALUE(&generator->value, value);
28881
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28882
0
          Z_ADDREF(generator->value);
28883
0
        }
28884
0
      } else if (IS_VAR == IS_TMP_VAR) {
28885
0
        ZVAL_COPY_VALUE(&generator->value, value);
28886
0
      } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
28887
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
28888
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28889
0
      } else {
28890
0
        ZVAL_COPY_VALUE(&generator->value, value);
28891
0
        if (IS_VAR == IS_CV) {
28892
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
28893
0
        }
28894
0
      }
28895
0
    }
28896
0
  } else {
28897
    /* If no value was specified yield null */
28898
0
    ZVAL_NULL(&generator->value);
28899
0
  }
28900
28901
  /* Set the new yielded key */
28902
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28903
0
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28904
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
28905
0
      key = Z_REFVAL_P(key);
28906
0
    }
28907
0
    ZVAL_COPY(&generator->key, key);
28908
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28909
28910
0
    if (Z_TYPE(generator->key) == IS_LONG
28911
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
28912
0
    ) {
28913
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
28914
0
    }
28915
0
  } else {
28916
    /* If no key was specified we use auto-increment keys */
28917
0
    generator->largest_used_integer_key++;
28918
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
28919
0
  }
28920
28921
0
  if (RETURN_VALUE_USED(opline)) {
28922
    /* If the return value of yield is used set the send
28923
     * target and initialize it to NULL */
28924
0
    generator->send_target = EX_VAR(opline->result.var);
28925
0
    ZVAL_NULL(generator->send_target);
28926
0
  } else {
28927
0
    generator->send_target = NULL;
28928
0
  }
28929
28930
  /* The GOTO VM uses a local opline variable. We need to set the opline
28931
   * variable in execute_data so we don't resume at an old position. */
28932
0
  SAVE_OPLINE();
28933
28934
0
  ZEND_VM_RETURN();
28935
0
}
28936
28937
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28938
35
{
28939
35
  USE_OPLINE
28940
35
  zval *op1, *op2;
28941
35
  bool result;
28942
28943
35
  SAVE_OPLINE();
28944
35
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28945
35
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28946
35
  result = fast_is_identical_function(op1, op2);
28947
35
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28948
35
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28949
35
  ZEND_VM_SMART_BRANCH(result, 1);
28950
35
}
28951
28952
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28953
0
{
28954
0
  USE_OPLINE
28955
0
  zval *op1, *op2;
28956
0
  bool result;
28957
28958
0
  SAVE_OPLINE();
28959
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28960
0
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28961
0
  result = fast_is_identical_function(op1, op2);
28962
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28963
0
  ZEND_VM_SMART_BRANCH(result, 1);
28964
0
}
28965
28966
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28967
0
{
28968
0
  USE_OPLINE
28969
0
  zval *op1, *op2;
28970
0
  bool result;
28971
28972
0
  SAVE_OPLINE();
28973
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28974
0
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28975
0
  result = fast_is_not_identical_function(op1, op2);
28976
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28977
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28978
0
  ZEND_VM_SMART_BRANCH(result, 1);
28979
0
}
28980
28981
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28982
1.47k
{
28983
1.47k
  USE_OPLINE
28984
1.47k
  zval *value;
28985
1.47k
  zval *variable_ptr;
28986
28987
1.47k
  SAVE_OPLINE();
28988
1.47k
  value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28989
1.47k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28990
28991
1.47k
  if (0 || UNEXPECTED(0)) {
28992
0
    zend_refcounted *garbage = NULL;
28993
28994
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28995
0
    if (UNEXPECTED(0)) {
28996
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
28997
0
    }
28998
0
    if (garbage) {
28999
0
      GC_DTOR_NO_REF(garbage);
29000
0
    }
29001
1.47k
  } else {
29002
1.47k
    value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
29003
1.47k
  }
29004
1.47k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29005
  /* zend_assign_to_variable() always takes care of op2, never free it! */
29006
29007
1.47k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29008
1.47k
}
29009
29010
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29011
4.87k
{
29012
4.87k
  USE_OPLINE
29013
4.87k
  zval *value;
29014
4.87k
  zval *variable_ptr;
29015
29016
4.87k
  SAVE_OPLINE();
29017
4.87k
  value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
29018
4.87k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29019
29020
4.87k
  if (0 || UNEXPECTED(1)) {
29021
4.87k
    zend_refcounted *garbage = NULL;
29022
29023
4.87k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
29024
4.87k
    if (UNEXPECTED(1)) {
29025
4.87k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29026
4.87k
    }
29027
4.87k
    if (garbage) {
29028
208
      GC_DTOR_NO_REF(garbage);
29029
208
    }
29030
4.87k
  } else {
29031
0
    value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
29032
0
  }
29033
4.87k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29034
  /* zend_assign_to_variable() always takes care of op2, never free it! */
29035
29036
4.87k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29037
4.87k
}
29038
29039
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29040
31
{
29041
31
  USE_OPLINE
29042
31
  zval *op1, *op2;
29043
31
  bool result;
29044
29045
31
  SAVE_OPLINE();
29046
31
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
29047
31
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
29048
31
  result = fast_is_identical_function(op1, op2);
29049
31
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29050
31
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29051
31
  ZEND_VM_SMART_BRANCH(result, 1);
29052
31
}
29053
29054
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29055
0
{
29056
0
  USE_OPLINE
29057
0
  zval *op1, *op2;
29058
0
  bool result;
29059
29060
0
  SAVE_OPLINE();
29061
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
29062
0
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
29063
0
  result = fast_is_identical_function(op1, op2);
29064
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29065
0
  ZEND_VM_SMART_BRANCH(result, 1);
29066
0
}
29067
29068
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29069
0
{
29070
0
  USE_OPLINE
29071
0
  zval *op1, *op2;
29072
0
  bool result;
29073
29074
0
  SAVE_OPLINE();
29075
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
29076
0
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
29077
0
  result = fast_is_not_identical_function(op1, op2);
29078
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29079
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29080
0
  ZEND_VM_SMART_BRANCH(result, 1);
29081
0
}
29082
29083
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29084
8.37k
{
29085
8.37k
  USE_OPLINE
29086
8.37k
  zval *value;
29087
8.37k
  zval *variable_ptr;
29088
29089
8.37k
  SAVE_OPLINE();
29090
8.37k
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
29091
8.37k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29092
29093
8.37k
  if (0 || UNEXPECTED(0)) {
29094
0
    zend_refcounted *garbage = NULL;
29095
29096
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29097
0
    if (UNEXPECTED(0)) {
29098
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29099
0
    }
29100
0
    if (garbage) {
29101
0
      GC_DTOR_NO_REF(garbage);
29102
0
    }
29103
8.37k
  } else {
29104
8.37k
    value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
29105
8.37k
  }
29106
8.37k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29107
  /* zend_assign_to_variable() always takes care of op2, never free it! */
29108
29109
8.37k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29110
8.37k
}
29111
29112
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29113
0
{
29114
0
  USE_OPLINE
29115
0
  zval *value;
29116
0
  zval *variable_ptr;
29117
29118
0
  SAVE_OPLINE();
29119
0
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
29120
0
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29121
29122
0
  if (0 || UNEXPECTED(1)) {
29123
0
    zend_refcounted *garbage = NULL;
29124
29125
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29126
0
    if (UNEXPECTED(1)) {
29127
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29128
0
    }
29129
0
    if (garbage) {
29130
0
      GC_DTOR_NO_REF(garbage);
29131
0
    }
29132
0
  } else {
29133
0
    value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
29134
0
  }
29135
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29136
  /* zend_assign_to_variable() always takes care of op2, never free it! */
29137
29138
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29139
0
}
29140
29141
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29142
2.61k
{
29143
2.61k
  USE_OPLINE
29144
2.61k
  zval *variable_ptr;
29145
2.61k
  zval *value_ptr;
29146
2.61k
  zend_refcounted *garbage = NULL;
29147
29148
2.61k
  SAVE_OPLINE();
29149
2.61k
  value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
29150
2.61k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29151
29152
2.61k
  if (IS_VAR == IS_VAR &&
29153
2.61k
             UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
29154
29155
0
    zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
29156
0
    variable_ptr = &EG(uninitialized_zval);
29157
2.61k
  } else if (IS_VAR == IS_VAR &&
29158
2.61k
             opline->extended_value == ZEND_RETURNS_FUNCTION &&
29159
2.61k
         UNEXPECTED(!Z_ISREF_P(value_ptr))) {
29160
29161
5
    variable_ptr = zend_wrong_assign_to_variable_reference(
29162
5
      variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
29163
2.60k
  } else {
29164
2.60k
    zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
29165
2.60k
  }
29166
29167
2.61k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29168
99
    ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
29169
99
  }
29170
29171
2.61k
  if (garbage) {
29172
39
    GC_DTOR(garbage);
29173
39
  }
29174
29175
2.61k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29176
2.61k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29177
2.61k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29178
2.61k
}
29179
29180
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29181
7
{
29182
7
  USE_OPLINE
29183
7
  zval *var_ptr;
29184
7
  zval *value, *container, *dim;
29185
7
  HashTable *ht;
29186
29187
7
  SAVE_OPLINE();
29188
7
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29189
29190
7
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
29191
0
assign_dim_op_array:
29192
0
    SEPARATE_ARRAY(container);
29193
0
    ht = Z_ARRVAL_P(container);
29194
7
assign_dim_op_new_array:
29195
7
    dim = NULL;
29196
7
    if (IS_UNUSED == IS_UNUSED) {
29197
7
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
29198
7
      if (UNEXPECTED(!var_ptr)) {
29199
0
        zend_cannot_add_element();
29200
0
        goto assign_dim_op_ret_null;
29201
0
      }
29202
7
    } else {
29203
0
      if (IS_UNUSED == IS_CONST) {
29204
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
29205
0
      } else {
29206
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
29207
0
      }
29208
0
      if (UNEXPECTED(!var_ptr)) {
29209
0
        goto assign_dim_op_ret_null;
29210
0
      }
29211
0
    }
29212
29213
7
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
29214
29215
7
    do {
29216
7
      if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
29217
0
        zend_reference *ref = Z_REF_P(var_ptr);
29218
0
        var_ptr = Z_REFVAL_P(var_ptr);
29219
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
29220
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
29221
0
          break;
29222
0
        }
29223
0
      }
29224
7
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
29225
7
    } while (0);
29226
29227
7
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29228
0
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
29229
0
    }
29230
7
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
29231
7
  } else {
29232
7
    if (EXPECTED(Z_ISREF_P(container))) {
29233
0
      container = Z_REFVAL_P(container);
29234
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
29235
0
        goto assign_dim_op_array;
29236
0
      }
29237
0
    }
29238
29239
7
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
29240
0
      zend_object *obj = Z_OBJ_P(container);
29241
29242
0
      dim = NULL;
29243
0
      if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29244
0
        dim++;
29245
0
      }
29246
0
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
29247
7
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
29248
7
      uint8_t old_type;
29249
29250
7
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
29251
0
        ZVAL_UNDEFINED_OP1();
29252
0
      }
29253
7
      ht = zend_new_array(8);
29254
7
      old_type = Z_TYPE_P(container);
29255
7
      ZVAL_ARR(container, ht);
29256
7
      if (UNEXPECTED(old_type == IS_FALSE)) {
29257
0
        GC_ADDREF(ht);
29258
0
        zend_false_to_array_deprecated();
29259
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29260
0
          zend_array_destroy(ht);
29261
0
          goto assign_dim_op_ret_null;
29262
0
        }
29263
0
      }
29264
7
      goto assign_dim_op_new_array;
29265
7
    } else {
29266
0
      dim = NULL;
29267
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
29268
0
assign_dim_op_ret_null:
29269
0
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
29270
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29271
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29272
0
      }
29273
0
    }
29274
7
  }
29275
29276
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29277
7
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29278
7
}
29279
29280
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29281
83
{
29282
83
  USE_OPLINE
29283
83
  zval *container;
29284
29285
83
  SAVE_OPLINE();
29286
83
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29287
83
  zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
29288
29289
83
  if (IS_VAR == IS_VAR) {
29290
83
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
29291
83
  }
29292
83
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29293
83
}
29294
29295
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29296
5
{
29297
5
  USE_OPLINE
29298
5
  zval *container;
29299
29300
5
  SAVE_OPLINE();
29301
5
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29302
5
  zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
29303
29304
5
  if (IS_VAR == IS_VAR) {
29305
5
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
29306
5
  }
29307
5
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29308
5
}
29309
29310
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29311
0
{
29312
#if 0
29313
  USE_OPLINE
29314
#endif
29315
29316
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
29317
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
29318
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29319
0
    }
29320
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29321
0
  } else {
29322
0
    if (IS_UNUSED == IS_UNUSED) {
29323
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29324
0
    }
29325
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29326
0
  }
29327
0
}
29328
29329
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29330
1.13k
{
29331
1.13k
  USE_OPLINE
29332
1.13k
  zval *object_ptr, *orig_object_ptr;
29333
1.13k
  zval *value;
29334
1.13k
  zval *variable_ptr;
29335
1.13k
  zval *dim;
29336
1.13k
  zend_refcounted *garbage = NULL;
29337
29338
1.13k
  SAVE_OPLINE();
29339
1.13k
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29340
29341
1.13k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29342
1.12k
try_assign_dim_array:
29343
1.12k
    SEPARATE_ARRAY(object_ptr);
29344
1.12k
    if (IS_UNUSED == IS_UNUSED) {
29345
1.12k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
29346
1.12k
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29347
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
29348
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29349
0
          GC_ADDREF(ht);
29350
0
        }
29351
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29352
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29353
0
          zend_array_destroy(ht);
29354
0
          goto assign_dim_error;
29355
0
        }
29356
0
      }
29357
1.12k
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
29358
0
        ZVAL_DEREF(value);
29359
0
      }
29360
1.12k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29361
1.12k
      if (UNEXPECTED(value == NULL)) {
29362
5
        zend_cannot_add_element();
29363
5
        goto assign_dim_error;
29364
1.12k
      } else if (IS_CONST == IS_CV) {
29365
0
        if (Z_REFCOUNTED_P(value)) {
29366
0
          Z_ADDREF_P(value);
29367
0
        }
29368
1.12k
      } else if (IS_CONST == IS_VAR) {
29369
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
29370
0
        if (Z_ISREF_P(free_op_data)) {
29371
0
          if (Z_REFCOUNTED_P(value)) {
29372
0
            Z_ADDREF_P(value);
29373
0
          }
29374
0
          zval_ptr_dtor_nogc(free_op_data);
29375
0
        }
29376
1.12k
      } else if (IS_CONST == IS_CONST) {
29377
1.12k
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29378
0
          Z_ADDREF_P(value);
29379
0
        }
29380
1.12k
      }
29381
1.12k
    } else {
29382
0
      dim = NULL;
29383
0
      if (IS_UNUSED == IS_CONST) {
29384
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29385
0
      } else {
29386
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29387
0
      }
29388
0
      if (UNEXPECTED(variable_ptr == NULL)) {
29389
0
        goto assign_dim_error;
29390
0
      }
29391
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
29392
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
29393
0
    }
29394
1.12k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29395
37
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29396
37
    }
29397
1.12k
    if (garbage) {
29398
0
      GC_DTOR_NO_REF(garbage);
29399
0
    }
29400
1.12k
  } else {
29401
315
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
29402
31
      object_ptr = Z_REFVAL_P(object_ptr);
29403
31
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29404
31
        goto try_assign_dim_array;
29405
31
      }
29406
31
    }
29407
284
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29408
10
      zend_object *obj = Z_OBJ_P(object_ptr);
29409
29410
10
      GC_ADDREF(obj);
29411
10
      dim = NULL;
29412
10
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29413
0
        dim = ZVAL_UNDEFINED_OP2();
29414
10
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29415
0
        dim++;
29416
0
      }
29417
29418
10
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
29419
10
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29420
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29421
10
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
29422
0
        ZVAL_DEREF(value);
29423
0
      }
29424
29425
10
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29426
29427
10
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29428
0
        zend_objects_store_del(obj);
29429
0
      }
29430
274
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29431
0
      if (IS_UNUSED == IS_UNUSED) {
29432
0
        zend_use_new_element_for_string();
29433
29434
0
        UNDEF_RESULT();
29435
0
      } else {
29436
0
        dim = NULL;
29437
0
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
29438
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29439
29440
0
      }
29441
274
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29442
274
      if (Z_ISREF_P(orig_object_ptr)
29443
274
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29444
274
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29445
0
        dim = NULL;
29446
29447
0
        UNDEF_RESULT();
29448
274
      } else {
29449
274
        HashTable *ht = zend_new_array(8);
29450
274
        uint8_t old_type = Z_TYPE_P(object_ptr);
29451
29452
274
        ZVAL_ARR(object_ptr, ht);
29453
274
        if (UNEXPECTED(old_type == IS_FALSE)) {
29454
132
          GC_ADDREF(ht);
29455
132
          zend_false_to_array_deprecated();
29456
132
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29457
0
            zend_array_destroy(ht);
29458
0
            goto assign_dim_error;
29459
0
          }
29460
132
        }
29461
274
        goto try_assign_dim_array;
29462
274
      }
29463
274
    } else {
29464
0
      zend_use_scalar_as_array();
29465
0
      dim = NULL;
29466
5
assign_dim_error:
29467
29468
5
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29469
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29470
0
      }
29471
5
    }
29472
284
  }
29473
1.13k
  if (IS_UNUSED != IS_UNUSED) {
29474
29475
0
  }
29476
1.13k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29477
  /* assign_dim has two opcodes! */
29478
1.13k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29479
1.13k
}
29480
29481
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29482
889
{
29483
889
  USE_OPLINE
29484
889
  zval *object_ptr, *orig_object_ptr;
29485
889
  zval *value;
29486
889
  zval *variable_ptr;
29487
889
  zval *dim;
29488
889
  zend_refcounted *garbage = NULL;
29489
29490
889
  SAVE_OPLINE();
29491
889
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29492
29493
889
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29494
889
try_assign_dim_array:
29495
889
    SEPARATE_ARRAY(object_ptr);
29496
889
    if (IS_UNUSED == IS_UNUSED) {
29497
889
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29498
889
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29499
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
29500
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29501
0
          GC_ADDREF(ht);
29502
0
        }
29503
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29504
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29505
0
          zend_array_destroy(ht);
29506
0
          goto assign_dim_error;
29507
0
        }
29508
0
      }
29509
889
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
29510
0
        ZVAL_DEREF(value);
29511
0
      }
29512
889
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29513
889
      if (UNEXPECTED(value == NULL)) {
29514
0
        zend_cannot_add_element();
29515
0
        goto assign_dim_error;
29516
889
      } else if (IS_TMP_VAR == IS_CV) {
29517
0
        if (Z_REFCOUNTED_P(value)) {
29518
0
          Z_ADDREF_P(value);
29519
0
        }
29520
889
      } else if (IS_TMP_VAR == IS_VAR) {
29521
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
29522
0
        if (Z_ISREF_P(free_op_data)) {
29523
0
          if (Z_REFCOUNTED_P(value)) {
29524
0
            Z_ADDREF_P(value);
29525
0
          }
29526
0
          zval_ptr_dtor_nogc(free_op_data);
29527
0
        }
29528
889
      } else if (IS_TMP_VAR == IS_CONST) {
29529
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29530
0
          Z_ADDREF_P(value);
29531
0
        }
29532
0
      }
29533
889
    } else {
29534
0
      dim = NULL;
29535
0
      if (IS_UNUSED == IS_CONST) {
29536
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29537
0
      } else {
29538
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29539
0
      }
29540
0
      if (UNEXPECTED(variable_ptr == NULL)) {
29541
0
        goto assign_dim_error;
29542
0
      }
29543
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29544
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
29545
0
    }
29546
889
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29547
7
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29548
7
    }
29549
889
    if (garbage) {
29550
0
      GC_DTOR_NO_REF(garbage);
29551
0
    }
29552
889
  } else {
29553
92
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
29554
7
      object_ptr = Z_REFVAL_P(object_ptr);
29555
7
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29556
7
        goto try_assign_dim_array;
29557
7
      }
29558
7
    }
29559
85
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29560
0
      zend_object *obj = Z_OBJ_P(object_ptr);
29561
29562
0
      GC_ADDREF(obj);
29563
0
      dim = NULL;
29564
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29565
0
        dim = ZVAL_UNDEFINED_OP2();
29566
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29567
0
        dim++;
29568
0
      }
29569
29570
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29571
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29572
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29573
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
29574
0
        ZVAL_DEREF(value);
29575
0
      }
29576
29577
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29578
29579
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29580
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29581
0
        zend_objects_store_del(obj);
29582
0
      }
29583
85
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29584
0
      if (IS_UNUSED == IS_UNUSED) {
29585
0
        zend_use_new_element_for_string();
29586
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29587
0
        UNDEF_RESULT();
29588
0
      } else {
29589
0
        dim = NULL;
29590
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29591
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29592
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29593
0
      }
29594
85
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29595
85
      if (Z_ISREF_P(orig_object_ptr)
29596
85
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29597
85
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29598
0
        dim = NULL;
29599
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29600
0
        UNDEF_RESULT();
29601
85
      } else {
29602
85
        HashTable *ht = zend_new_array(8);
29603
85
        uint8_t old_type = Z_TYPE_P(object_ptr);
29604
29605
85
        ZVAL_ARR(object_ptr, ht);
29606
85
        if (UNEXPECTED(old_type == IS_FALSE)) {
29607
0
          GC_ADDREF(ht);
29608
0
          zend_false_to_array_deprecated();
29609
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29610
0
            zend_array_destroy(ht);
29611
0
            goto assign_dim_error;
29612
0
          }
29613
0
        }
29614
85
        goto try_assign_dim_array;
29615
85
      }
29616
85
    } else {
29617
0
      zend_use_scalar_as_array();
29618
0
      dim = NULL;
29619
0
assign_dim_error:
29620
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29621
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29622
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29623
0
      }
29624
0
    }
29625
85
  }
29626
889
  if (IS_UNUSED != IS_UNUSED) {
29627
29628
0
  }
29629
889
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29630
  /* assign_dim has two opcodes! */
29631
889
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29632
889
}
29633
29634
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29635
433
{
29636
433
  USE_OPLINE
29637
433
  zval *object_ptr, *orig_object_ptr;
29638
433
  zval *value;
29639
433
  zval *variable_ptr;
29640
433
  zval *dim;
29641
433
  zend_refcounted *garbage = NULL;
29642
29643
433
  SAVE_OPLINE();
29644
433
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29645
29646
433
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29647
433
try_assign_dim_array:
29648
433
    SEPARATE_ARRAY(object_ptr);
29649
433
    if (IS_UNUSED == IS_UNUSED) {
29650
433
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29651
433
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29652
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
29653
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29654
0
          GC_ADDREF(ht);
29655
0
        }
29656
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29657
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29658
0
          zend_array_destroy(ht);
29659
0
          goto assign_dim_error;
29660
0
        }
29661
0
      }
29662
433
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
29663
433
        ZVAL_DEREF(value);
29664
433
      }
29665
433
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29666
433
      if (UNEXPECTED(value == NULL)) {
29667
0
        zend_cannot_add_element();
29668
0
        goto assign_dim_error;
29669
433
      } else if (IS_VAR == IS_CV) {
29670
0
        if (Z_REFCOUNTED_P(value)) {
29671
0
          Z_ADDREF_P(value);
29672
0
        }
29673
433
      } else if (IS_VAR == IS_VAR) {
29674
433
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
29675
433
        if (Z_ISREF_P(free_op_data)) {
29676
0
          if (Z_REFCOUNTED_P(value)) {
29677
0
            Z_ADDREF_P(value);
29678
0
          }
29679
0
          zval_ptr_dtor_nogc(free_op_data);
29680
0
        }
29681
433
      } else if (IS_VAR == IS_CONST) {
29682
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29683
0
          Z_ADDREF_P(value);
29684
0
        }
29685
0
      }
29686
433
    } else {
29687
0
      dim = NULL;
29688
0
      if (IS_UNUSED == IS_CONST) {
29689
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29690
0
      } else {
29691
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29692
0
      }
29693
0
      if (UNEXPECTED(variable_ptr == NULL)) {
29694
0
        goto assign_dim_error;
29695
0
      }
29696
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29697
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29698
0
    }
29699
433
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29700
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29701
0
    }
29702
433
    if (garbage) {
29703
0
      GC_DTOR_NO_REF(garbage);
29704
0
    }
29705
433
  } else {
29706
16
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
29707
0
      object_ptr = Z_REFVAL_P(object_ptr);
29708
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29709
0
        goto try_assign_dim_array;
29710
0
      }
29711
0
    }
29712
16
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29713
0
      zend_object *obj = Z_OBJ_P(object_ptr);
29714
29715
0
      GC_ADDREF(obj);
29716
0
      dim = NULL;
29717
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29718
0
        dim = ZVAL_UNDEFINED_OP2();
29719
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29720
0
        dim++;
29721
0
      }
29722
29723
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29724
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29725
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29726
0
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
29727
0
        ZVAL_DEREF(value);
29728
0
      }
29729
29730
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29731
29732
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29733
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29734
0
        zend_objects_store_del(obj);
29735
0
      }
29736
16
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29737
0
      if (IS_UNUSED == IS_UNUSED) {
29738
0
        zend_use_new_element_for_string();
29739
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29740
0
        UNDEF_RESULT();
29741
0
      } else {
29742
0
        dim = NULL;
29743
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29744
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29745
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29746
0
      }
29747
16
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29748
16
      if (Z_ISREF_P(orig_object_ptr)
29749
16
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29750
16
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29751
0
        dim = NULL;
29752
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29753
0
        UNDEF_RESULT();
29754
16
      } else {
29755
16
        HashTable *ht = zend_new_array(8);
29756
16
        uint8_t old_type = Z_TYPE_P(object_ptr);
29757
29758
16
        ZVAL_ARR(object_ptr, ht);
29759
16
        if (UNEXPECTED(old_type == IS_FALSE)) {
29760
0
          GC_ADDREF(ht);
29761
0
          zend_false_to_array_deprecated();
29762
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29763
0
            zend_array_destroy(ht);
29764
0
            goto assign_dim_error;
29765
0
          }
29766
0
        }
29767
16
        goto try_assign_dim_array;
29768
16
      }
29769
16
    } else {
29770
0
      zend_use_scalar_as_array();
29771
0
      dim = NULL;
29772
0
assign_dim_error:
29773
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29774
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29775
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29776
0
      }
29777
0
    }
29778
16
  }
29779
433
  if (IS_UNUSED != IS_UNUSED) {
29780
29781
0
  }
29782
433
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29783
  /* assign_dim has two opcodes! */
29784
433
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29785
433
}
29786
29787
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29788
631
{
29789
631
  USE_OPLINE
29790
631
  zval *object_ptr, *orig_object_ptr;
29791
631
  zval *value;
29792
631
  zval *variable_ptr;
29793
631
  zval *dim;
29794
631
  zend_refcounted *garbage = NULL;
29795
29796
631
  SAVE_OPLINE();
29797
631
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29798
29799
631
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29800
631
try_assign_dim_array:
29801
631
    SEPARATE_ARRAY(object_ptr);
29802
631
    if (IS_UNUSED == IS_UNUSED) {
29803
631
      value = EX_VAR((opline+1)->op1.var);
29804
631
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29805
388
        HashTable *ht = Z_ARRVAL_P(object_ptr);
29806
388
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29807
388
          GC_ADDREF(ht);
29808
388
        }
29809
388
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29810
388
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29811
0
          zend_array_destroy(ht);
29812
0
          goto assign_dim_error;
29813
0
        }
29814
388
      }
29815
631
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
29816
631
        ZVAL_DEREF(value);
29817
631
      }
29818
631
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29819
631
      if (UNEXPECTED(value == NULL)) {
29820
0
        zend_cannot_add_element();
29821
0
        goto assign_dim_error;
29822
631
      } else if (IS_CV == IS_CV) {
29823
631
        if (Z_REFCOUNTED_P(value)) {
29824
42
          Z_ADDREF_P(value);
29825
42
        }
29826
631
      } else if (IS_CV == IS_VAR) {
29827
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
29828
0
        if (Z_ISREF_P(free_op_data)) {
29829
0
          if (Z_REFCOUNTED_P(value)) {
29830
0
            Z_ADDREF_P(value);
29831
0
          }
29832
0
          zval_ptr_dtor_nogc(free_op_data);
29833
0
        }
29834
0
      } else if (IS_CV == IS_CONST) {
29835
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29836
0
          Z_ADDREF_P(value);
29837
0
        }
29838
0
      }
29839
631
    } else {
29840
0
      dim = NULL;
29841
0
      if (IS_UNUSED == IS_CONST) {
29842
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29843
0
      } else {
29844
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29845
0
      }
29846
0
      if (UNEXPECTED(variable_ptr == NULL)) {
29847
0
        goto assign_dim_error;
29848
0
      }
29849
0
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
29850
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
29851
0
    }
29852
631
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29853
218
      ZVAL_COPY(EX_VAR(opline->result.var), value);
29854
218
    }
29855
631
    if (garbage) {
29856
0
      GC_DTOR_NO_REF(garbage);
29857
0
    }
29858
631
  } else {
29859
233
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
29860
0
      object_ptr = Z_REFVAL_P(object_ptr);
29861
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29862
0
        goto try_assign_dim_array;
29863
0
      }
29864
0
    }
29865
233
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29866
0
      zend_object *obj = Z_OBJ_P(object_ptr);
29867
29868
0
      GC_ADDREF(obj);
29869
0
      dim = NULL;
29870
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29871
0
        dim = ZVAL_UNDEFINED_OP2();
29872
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29873
0
        dim++;
29874
0
      }
29875
29876
0
      value = EX_VAR((opline+1)->op1.var);
29877
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29878
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29879
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
29880
0
        ZVAL_DEREF(value);
29881
0
      }
29882
29883
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29884
29885
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29886
0
        zend_objects_store_del(obj);
29887
0
      }
29888
233
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29889
0
      if (IS_UNUSED == IS_UNUSED) {
29890
0
        zend_use_new_element_for_string();
29891
29892
0
        UNDEF_RESULT();
29893
0
      } else {
29894
0
        dim = NULL;
29895
0
        value = EX_VAR((opline+1)->op1.var);
29896
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29897
29898
0
      }
29899
233
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29900
233
      if (Z_ISREF_P(orig_object_ptr)
29901
233
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29902
233
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29903
0
        dim = NULL;
29904
29905
0
        UNDEF_RESULT();
29906
233
      } else {
29907
233
        HashTable *ht = zend_new_array(8);
29908
233
        uint8_t old_type = Z_TYPE_P(object_ptr);
29909
29910
233
        ZVAL_ARR(object_ptr, ht);
29911
233
        if (UNEXPECTED(old_type == IS_FALSE)) {
29912
0
          GC_ADDREF(ht);
29913
0
          zend_false_to_array_deprecated();
29914
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29915
0
            zend_array_destroy(ht);
29916
0
            goto assign_dim_error;
29917
0
          }
29918
0
        }
29919
233
        goto try_assign_dim_array;
29920
233
      }
29921
233
    } else {
29922
0
      zend_use_scalar_as_array();
29923
0
      dim = NULL;
29924
0
assign_dim_error:
29925
29926
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29927
0
        ZVAL_NULL(EX_VAR(opline->result.var));
29928
0
      }
29929
0
    }
29930
233
  }
29931
631
  if (IS_UNUSED != IS_UNUSED) {
29932
29933
0
  }
29934
631
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29935
  /* assign_dim has two opcodes! */
29936
631
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
29937
631
}
29938
29939
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29940
0
{
29941
0
  USE_OPLINE
29942
0
  zval *function_name;
29943
0
  zend_class_entry *ce;
29944
0
  uint32_t call_info;
29945
0
  zend_function *fbc;
29946
0
  zend_execute_data *call;
29947
29948
0
  SAVE_OPLINE();
29949
29950
0
  if (IS_VAR == IS_CONST) {
29951
    /* no function found. try a static method in class */
29952
0
    ce = CACHED_PTR(opline->result.num);
29953
0
    if (UNEXPECTED(ce == NULL)) {
29954
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);
29955
0
      if (UNEXPECTED(ce == NULL)) {
29956
29957
0
        HANDLE_EXCEPTION();
29958
0
      }
29959
0
      if (IS_UNUSED != IS_CONST) {
29960
0
        CACHE_PTR(opline->result.num, ce);
29961
0
      }
29962
0
    }
29963
0
  } else if (IS_VAR == IS_UNUSED) {
29964
0
    ce = zend_fetch_class(NULL, opline->op1.num);
29965
0
    if (UNEXPECTED(ce == NULL)) {
29966
29967
0
      HANDLE_EXCEPTION();
29968
0
    }
29969
0
  } else {
29970
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
29971
0
  }
29972
29973
0
  if (IS_VAR == IS_CONST &&
29974
0
      IS_UNUSED == IS_CONST &&
29975
0
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
29976
    /* nothing to do */
29977
0
  } else if (IS_VAR != IS_CONST &&
29978
0
             IS_UNUSED == IS_CONST &&
29979
0
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
29980
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
29981
0
  } else if (IS_UNUSED != IS_UNUSED) {
29982
0
    function_name = NULL;
29983
0
    if (IS_UNUSED != IS_CONST) {
29984
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
29985
0
        do {
29986
0
          if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
29987
0
            function_name = Z_REFVAL_P(function_name);
29988
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
29989
0
              break;
29990
0
            }
29991
0
          } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
29992
0
            ZVAL_UNDEFINED_OP2();
29993
0
            if (UNEXPECTED(EG(exception) != NULL)) {
29994
0
              HANDLE_EXCEPTION();
29995
0
            }
29996
0
          }
29997
0
          zend_throw_error(NULL, "Method name must be a string");
29998
29999
0
          HANDLE_EXCEPTION();
30000
0
        } while (0);
30001
0
      }
30002
0
    }
30003
30004
0
    if (ce->get_static_method) {
30005
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
30006
0
    } else {
30007
0
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
30008
0
    }
30009
0
    if (UNEXPECTED(fbc == NULL)) {
30010
0
      if (EXPECTED(!EG(exception))) {
30011
0
        zend_undefined_method(ce, Z_STR_P(function_name));
30012
0
      }
30013
30014
0
      HANDLE_EXCEPTION();
30015
0
    }
30016
0
    if (IS_UNUSED == IS_CONST &&
30017
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
30018
0
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
30019
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
30020
0
    }
30021
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
30022
0
      init_func_run_time_cache(&fbc->op_array);
30023
0
    }
30024
0
    if (IS_UNUSED != IS_CONST) {
30025
30026
0
    }
30027
0
  } else {
30028
0
    if (UNEXPECTED(ce->constructor == NULL)) {
30029
0
      zend_throw_error(NULL, "Cannot call constructor");
30030
0
      HANDLE_EXCEPTION();
30031
0
    }
30032
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)) {
30033
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
30034
0
      HANDLE_EXCEPTION();
30035
0
    }
30036
0
    fbc = ce->constructor;
30037
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
30038
0
      init_func_run_time_cache(&fbc->op_array);
30039
0
    }
30040
0
  }
30041
30042
0
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
30043
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
30044
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
30045
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
30046
0
    } else {
30047
0
      zend_non_static_method_call(fbc);
30048
0
      HANDLE_EXCEPTION();
30049
0
    }
30050
0
  } else {
30051
    /* previous opcode is ZEND_FETCH_CLASS */
30052
0
    if (IS_VAR == IS_UNUSED
30053
0
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
30054
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
30055
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
30056
0
        ce = Z_OBJCE(EX(This));
30057
0
      } else {
30058
0
        ce = Z_CE(EX(This));
30059
0
      }
30060
0
    }
30061
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
30062
0
  }
30063
30064
0
  call = zend_vm_stack_push_call_frame(call_info,
30065
0
    fbc, opline->extended_value, ce);
30066
0
  call->prev_execute_data = EX(call);
30067
0
  EX(call) = call;
30068
30069
0
  ZEND_VM_NEXT_OPCODE();
30070
0
}
30071
30072
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30073
281
{
30074
281
  if (IS_VAR == IS_UNUSED) {
30075
0
    SAVE_OPLINE();
30076
0
    zend_verify_missing_return_type(EX(func));
30077
0
    HANDLE_EXCEPTION();
30078
281
  } else {
30079
/* prevents "undefined variable opline" errors */
30080
281
#if 0 || (IS_VAR != IS_UNUSED)
30081
281
    USE_OPLINE
30082
281
    zval *retval_ref, *retval_ptr;
30083
281
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
30084
281
    retval_ref = retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30085
30086
281
    if (IS_VAR == IS_CONST) {
30087
0
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
30088
0
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
30089
281
    } else if (IS_VAR == IS_VAR) {
30090
281
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
30091
22
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
30092
22
      }
30093
281
      ZVAL_DEREF(retval_ptr);
30094
281
    } else if (IS_VAR == IS_CV) {
30095
0
      ZVAL_DEREF(retval_ptr);
30096
0
    }
30097
30098
281
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
30099
92
      ZEND_VM_NEXT_OPCODE();
30100
92
    }
30101
30102
189
    if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
30103
0
      SAVE_OPLINE();
30104
0
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
30105
0
      if (UNEXPECTED(EG(exception))) {
30106
0
        HANDLE_EXCEPTION();
30107
0
      }
30108
0
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
30109
0
        ZEND_VM_NEXT_OPCODE();
30110
0
      }
30111
0
    }
30112
30113
189
    zend_reference *ref = NULL;
30114
189
    if (UNEXPECTED(retval_ref != retval_ptr)) {
30115
0
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
30116
0
        ref = Z_REF_P(retval_ref);
30117
0
      } else {
30118
        /* A cast might happen - unwrap the reference if this is a by-value return */
30119
0
        if (Z_REFCOUNT_P(retval_ref) == 1) {
30120
0
          ZVAL_UNREF(retval_ref);
30121
0
        } else {
30122
0
          Z_DELREF_P(retval_ref);
30123
0
          ZVAL_COPY(retval_ref, retval_ptr);
30124
0
        }
30125
0
        retval_ptr = retval_ref;
30126
0
      }
30127
0
    }
30128
30129
189
    SAVE_OPLINE();
30130
189
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
30131
66
      zend_verify_return_error(EX(func), retval_ptr);
30132
66
      HANDLE_EXCEPTION();
30133
66
    }
30134
123
    ZEND_VM_NEXT_OPCODE();
30135
123
#endif
30136
123
  }
30137
281
}
30138
30139
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30140
141k
{
30141
141k
  USE_OPLINE
30142
141k
  zval *varptr, *arg;
30143
30144
141k
  if (IS_UNUSED == IS_CONST) {
30145
0
    SAVE_OPLINE();
30146
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30147
0
    uint32_t arg_num;
30148
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30149
0
    if (UNEXPECTED(!arg)) {
30150
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30151
0
      HANDLE_EXCEPTION();
30152
0
    }
30153
141k
  } else {
30154
141k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30155
141k
  }
30156
30157
141k
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30158
141k
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30159
0
    SAVE_OPLINE();
30160
0
    ZVAL_UNDEFINED_OP1();
30161
0
    ZVAL_NULL(arg);
30162
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30163
0
  }
30164
30165
141k
  if (IS_VAR == IS_CV) {
30166
0
    ZVAL_COPY_DEREF(arg, varptr);
30167
141k
  } else /* if (IS_VAR == IS_VAR) */ {
30168
141k
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
30169
232
      zend_refcounted *ref = Z_COUNTED_P(varptr);
30170
30171
232
      varptr = Z_REFVAL_P(varptr);
30172
232
      ZVAL_COPY_VALUE(arg, varptr);
30173
232
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30174
52
        efree_size(ref, sizeof(zend_reference));
30175
180
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
30176
76
        Z_ADDREF_P(arg);
30177
76
      }
30178
141k
    } else {
30179
141k
      ZVAL_COPY_VALUE(arg, varptr);
30180
141k
    }
30181
141k
  }
30182
30183
141k
  ZEND_VM_NEXT_OPCODE();
30184
141k
}
30185
30186
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30187
238
{
30188
238
  USE_OPLINE
30189
238
  zval *varptr, *arg;
30190
30191
238
  if (IS_UNUSED == IS_CONST) {
30192
0
    SAVE_OPLINE();
30193
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30194
0
    uint32_t arg_num;
30195
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30196
0
    if (UNEXPECTED(!arg)) {
30197
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30198
0
      HANDLE_EXCEPTION();
30199
0
    }
30200
238
  } else {
30201
238
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30202
238
  }
30203
30204
238
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30205
238
  ZVAL_COPY_VALUE(arg, varptr);
30206
30207
238
  if (EXPECTED(Z_ISREF_P(varptr))) {
30208
221
    ZEND_VM_NEXT_OPCODE();
30209
221
  }
30210
30211
238
  SAVE_OPLINE();
30212
17
  ZVAL_NEW_REF(arg, arg);
30213
17
  zend_error(E_NOTICE, "Only variables should be passed by reference");
30214
17
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30215
17
}
30216
30217
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30218
0
{
30219
0
  USE_OPLINE
30220
0
  zval *varptr, *arg;
30221
0
  uint32_t arg_num;
30222
30223
0
  if (IS_UNUSED == IS_CONST) {
30224
0
    SAVE_OPLINE();
30225
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30226
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30227
0
    if (UNEXPECTED(!arg)) {
30228
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30229
0
      HANDLE_EXCEPTION();
30230
0
    }
30231
0
  } else {
30232
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30233
0
    arg_num = opline->op2.num;
30234
0
  }
30235
30236
0
  if (EXPECTED(0)) {
30237
0
    if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30238
0
      goto send_var;
30239
0
    }
30240
30241
0
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30242
0
    ZVAL_COPY_VALUE(arg, varptr);
30243
30244
0
    if (EXPECTED(Z_ISREF_P(varptr) ||
30245
0
        QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30246
0
      ZEND_VM_NEXT_OPCODE();
30247
0
    }
30248
0
  } else {
30249
0
    if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30250
0
      goto send_var;
30251
0
    }
30252
30253
0
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30254
0
    ZVAL_COPY_VALUE(arg, varptr);
30255
30256
0
    if (EXPECTED(Z_ISREF_P(varptr) ||
30257
0
        ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30258
0
      ZEND_VM_NEXT_OPCODE();
30259
0
    }
30260
0
  }
30261
30262
0
  SAVE_OPLINE();
30263
0
  ZVAL_NEW_REF(arg, arg);
30264
0
  zend_error(E_NOTICE, "Only variables should be passed by reference");
30265
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30266
30267
0
send_var:
30268
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30269
0
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
30270
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
30271
30272
0
    varptr = Z_REFVAL_P(varptr);
30273
0
    ZVAL_COPY_VALUE(arg, varptr);
30274
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30275
0
      efree_size(ref, sizeof(zend_reference));
30276
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
30277
0
      Z_ADDREF_P(arg);
30278
0
    }
30279
0
  } else {
30280
0
    ZVAL_COPY_VALUE(arg, varptr);
30281
0
  }
30282
0
  ZEND_VM_NEXT_OPCODE();
30283
0
}
30284
30285
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)
30286
2.02k
{
30287
2.02k
  USE_OPLINE
30288
2.02k
  zval *varptr, *arg;
30289
2.02k
  uint32_t arg_num;
30290
30291
2.02k
  if (IS_UNUSED == IS_CONST) {
30292
0
    SAVE_OPLINE();
30293
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30294
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30295
0
    if (UNEXPECTED(!arg)) {
30296
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30297
0
      HANDLE_EXCEPTION();
30298
0
    }
30299
2.02k
  } else {
30300
2.02k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30301
2.02k
    arg_num = opline->op2.num;
30302
2.02k
  }
30303
30304
2.02k
  if (EXPECTED(1)) {
30305
2.02k
    if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30306
2.01k
      goto send_var;
30307
2.01k
    }
30308
30309
10
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30310
10
    ZVAL_COPY_VALUE(arg, varptr);
30311
30312
10
    if (EXPECTED(Z_ISREF_P(varptr) ||
30313
10
        QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30314
10
      ZEND_VM_NEXT_OPCODE();
30315
10
    }
30316
10
  } else {
30317
0
    if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30318
0
      goto send_var;
30319
0
    }
30320
30321
0
    varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30322
0
    ZVAL_COPY_VALUE(arg, varptr);
30323
30324
0
    if (EXPECTED(Z_ISREF_P(varptr) ||
30325
0
        ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30326
0
      ZEND_VM_NEXT_OPCODE();
30327
0
    }
30328
0
  }
30329
30330
2.02k
  SAVE_OPLINE();
30331
0
  ZVAL_NEW_REF(arg, arg);
30332
0
  zend_error(E_NOTICE, "Only variables should be passed by reference");
30333
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30334
30335
2.01k
send_var:
30336
2.01k
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30337
2.01k
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
30338
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
30339
30340
0
    varptr = Z_REFVAL_P(varptr);
30341
0
    ZVAL_COPY_VALUE(arg, varptr);
30342
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30343
0
      efree_size(ref, sizeof(zend_reference));
30344
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
30345
0
      Z_ADDREF_P(arg);
30346
0
    }
30347
2.01k
  } else {
30348
2.01k
    ZVAL_COPY_VALUE(arg, varptr);
30349
2.01k
  }
30350
2.01k
  ZEND_VM_NEXT_OPCODE();
30351
2.01k
}
30352
30353
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30354
434
{
30355
434
  USE_OPLINE
30356
434
  zval *varptr, *arg;
30357
30358
434
  SAVE_OPLINE();
30359
434
  if (IS_UNUSED == IS_CONST) {
30360
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30361
0
    uint32_t arg_num;
30362
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30363
0
    if (UNEXPECTED(!arg)) {
30364
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30365
0
      HANDLE_EXCEPTION();
30366
0
    }
30367
434
  } else {
30368
434
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30369
434
  }
30370
30371
434
  varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30372
434
  if (Z_ISREF_P(varptr)) {
30373
89
    Z_ADDREF_P(varptr);
30374
345
  } else {
30375
345
    ZVAL_MAKE_REF_EX(varptr, 2);
30376
345
  }
30377
434
  ZVAL_REF(arg, Z_REF_P(varptr));
30378
30379
434
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30380
434
  ZEND_VM_NEXT_OPCODE();
30381
434
}
30382
30383
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30384
0
{
30385
0
  USE_OPLINE
30386
0
  zval *varptr, *arg;
30387
0
  uint32_t arg_num;
30388
30389
0
  if (IS_UNUSED == IS_CONST) {
30390
0
    SAVE_OPLINE();
30391
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30392
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30393
0
    if (UNEXPECTED(!arg)) {
30394
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30395
0
      HANDLE_EXCEPTION();
30396
0
    }
30397
0
  } else {
30398
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30399
0
    arg_num = opline->op2.num;
30400
0
  }
30401
30402
0
  if (EXPECTED(0)) {
30403
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30404
0
      goto send_var_by_ref;
30405
0
    }
30406
0
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30407
0
send_var_by_ref:
30408
0
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30409
0
    if (Z_ISREF_P(varptr)) {
30410
0
      Z_ADDREF_P(varptr);
30411
0
    } else {
30412
0
      ZVAL_MAKE_REF_EX(varptr, 2);
30413
0
    }
30414
0
    ZVAL_REF(arg, Z_REF_P(varptr));
30415
30416
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30417
0
    ZEND_VM_NEXT_OPCODE();
30418
0
  }
30419
30420
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30421
0
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30422
0
    SAVE_OPLINE();
30423
0
    ZVAL_UNDEFINED_OP1();
30424
0
    ZVAL_NULL(arg);
30425
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30426
0
  }
30427
30428
0
  if (IS_VAR == IS_CV) {
30429
0
    ZVAL_COPY_DEREF(arg, varptr);
30430
0
  } else /* if (IS_VAR == IS_VAR) */ {
30431
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
30432
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
30433
30434
0
      varptr = Z_REFVAL_P(varptr);
30435
0
      ZVAL_COPY_VALUE(arg, varptr);
30436
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30437
0
        efree_size(ref, sizeof(zend_reference));
30438
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
30439
0
        Z_ADDREF_P(arg);
30440
0
      }
30441
0
    } else {
30442
0
      ZVAL_COPY_VALUE(arg, varptr);
30443
0
    }
30444
0
  }
30445
30446
0
  ZEND_VM_NEXT_OPCODE();
30447
0
}
30448
30449
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30450
0
{
30451
0
  USE_OPLINE
30452
0
  zval *varptr, *arg;
30453
0
  uint32_t arg_num;
30454
30455
0
  if (IS_UNUSED == IS_CONST) {
30456
0
    SAVE_OPLINE();
30457
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30458
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30459
0
    if (UNEXPECTED(!arg)) {
30460
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30461
0
      HANDLE_EXCEPTION();
30462
0
    }
30463
0
  } else {
30464
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30465
0
    arg_num = opline->op2.num;
30466
0
  }
30467
30468
0
  if (EXPECTED(1)) {
30469
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30470
0
      goto send_var_by_ref;
30471
0
    }
30472
0
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30473
0
send_var_by_ref:
30474
0
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30475
0
    if (Z_ISREF_P(varptr)) {
30476
0
      Z_ADDREF_P(varptr);
30477
0
    } else {
30478
0
      ZVAL_MAKE_REF_EX(varptr, 2);
30479
0
    }
30480
0
    ZVAL_REF(arg, Z_REF_P(varptr));
30481
30482
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30483
0
    ZEND_VM_NEXT_OPCODE();
30484
0
  }
30485
30486
0
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30487
0
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30488
0
    SAVE_OPLINE();
30489
0
    ZVAL_UNDEFINED_OP1();
30490
0
    ZVAL_NULL(arg);
30491
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30492
0
  }
30493
30494
0
  if (IS_VAR == IS_CV) {
30495
0
    ZVAL_COPY_DEREF(arg, varptr);
30496
0
  } else /* if (IS_VAR == IS_VAR) */ {
30497
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
30498
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
30499
30500
0
      varptr = Z_REFVAL_P(varptr);
30501
0
      ZVAL_COPY_VALUE(arg, varptr);
30502
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30503
0
        efree_size(ref, sizeof(zend_reference));
30504
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
30505
0
        Z_ADDREF_P(arg);
30506
0
      }
30507
0
    } else {
30508
0
      ZVAL_COPY_VALUE(arg, varptr);
30509
0
    }
30510
0
  }
30511
30512
0
  ZEND_VM_NEXT_OPCODE();
30513
0
}
30514
30515
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30516
1.35k
{
30517
1.35k
  USE_OPLINE
30518
1.35k
  zval *varptr, *arg;
30519
30520
1.35k
  if (IS_UNUSED == IS_CONST) {
30521
    // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
30522
0
    SAVE_OPLINE();
30523
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30524
0
    uint32_t arg_num;
30525
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30526
0
    if (UNEXPECTED(!arg)) {
30527
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30528
0
      HANDLE_EXCEPTION();
30529
0
    }
30530
1.35k
  } else {
30531
1.35k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30532
1.35k
  }
30533
30534
1.35k
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
30535
45
    varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30536
45
    if (Z_ISREF_P(varptr)) {
30537
10
      Z_ADDREF_P(varptr);
30538
35
    } else {
30539
35
      ZVAL_MAKE_REF_EX(varptr, 2);
30540
35
    }
30541
45
    ZVAL_REF(arg, Z_REF_P(varptr));
30542
30543
45
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30544
45
    ZEND_VM_NEXT_OPCODE();
30545
45
  }
30546
30547
1.30k
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30548
30549
1.30k
  if (UNEXPECTED(Z_ISREF_P(varptr))) {
30550
0
    zend_refcounted *ref = Z_COUNTED_P(varptr);
30551
30552
0
    varptr = Z_REFVAL_P(varptr);
30553
0
    ZVAL_COPY_VALUE(arg, varptr);
30554
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30555
0
      efree_size(ref, sizeof(zend_reference));
30556
0
    } else if (Z_OPT_REFCOUNTED_P(arg)) {
30557
0
      Z_ADDREF_P(arg);
30558
0
    }
30559
1.30k
  } else {
30560
1.30k
    ZVAL_COPY_VALUE(arg, varptr);
30561
1.30k
  }
30562
30563
1.30k
  ZEND_VM_NEXT_OPCODE();
30564
1.30k
}
30565
30566
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30567
2.01k
{
30568
2.01k
  USE_OPLINE
30569
2.01k
  zval *result;
30570
2.01k
  zend_function *constructor;
30571
2.01k
  zend_class_entry *ce;
30572
2.01k
  zend_execute_data *call;
30573
30574
2.01k
  SAVE_OPLINE();
30575
2.01k
  if (IS_VAR == IS_CONST) {
30576
0
    ce = CACHED_PTR(opline->op2.num);
30577
0
    if (UNEXPECTED(ce == NULL)) {
30578
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);
30579
0
      if (UNEXPECTED(ce == NULL)) {
30580
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
30581
0
        HANDLE_EXCEPTION();
30582
0
      }
30583
0
      CACHE_PTR(opline->op2.num, ce);
30584
0
    }
30585
2.01k
  } else if (IS_VAR == IS_UNUSED) {
30586
0
    ce = zend_fetch_class(NULL, opline->op1.num);
30587
0
    if (UNEXPECTED(ce == NULL)) {
30588
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
30589
0
      HANDLE_EXCEPTION();
30590
0
    }
30591
2.01k
  } else {
30592
2.01k
    ce = Z_CE_P(EX_VAR(opline->op1.var));
30593
2.01k
  }
30594
30595
2.01k
  result = EX_VAR(opline->result.var);
30596
2.01k
  if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
30597
60
    ZVAL_UNDEF(result);
30598
60
    HANDLE_EXCEPTION();
30599
60
  }
30600
30601
1.95k
  constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
30602
1.95k
  if (constructor == NULL) {
30603
    /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
30604
     * opcode is DO_FCALL in case EXT instructions are used. */
30605
1.24k
    if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
30606
1.22k
      ZEND_VM_NEXT_OPCODE_EX(1, 2);
30607
1.22k
    }
30608
30609
24
    if (UNEXPECTED(EG(exception))) {
30610
0
      HANDLE_EXCEPTION();
30611
0
    }
30612
30613
    /* Perform a dummy function call */
30614
24
    call = zend_vm_stack_push_call_frame(
30615
24
      ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
30616
24
      opline->extended_value, NULL);
30617
706
  } else {
30618
706
    if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
30619
99
      init_func_run_time_cache(&constructor->op_array);
30620
99
    }
30621
    /* We are not handling overloaded classes right now */
30622
706
    call = zend_vm_stack_push_call_frame(
30623
706
      ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
30624
706
      constructor,
30625
706
      opline->extended_value,
30626
706
      Z_OBJ_P(result));
30627
706
    Z_ADDREF_P(result);
30628
706
  }
30629
30630
730
  call->prev_execute_data = EX(call);
30631
730
  EX(call) = call;
30632
730
  ZEND_VM_NEXT_OPCODE();
30633
730
}
30634
30635
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30636
2.27k
{
30637
2.27k
  USE_OPLINE
30638
2.27k
  zval *expr_ptr, new_expr;
30639
30640
2.27k
  SAVE_OPLINE();
30641
2.27k
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
30642
2.27k
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
30643
50
    expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30644
50
    if (Z_ISREF_P(expr_ptr)) {
30645
30
      Z_ADDREF_P(expr_ptr);
30646
30
    } else {
30647
20
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
30648
20
    }
30649
50
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30650
2.22k
  } else {
30651
2.22k
    expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30652
2.22k
    if (IS_VAR == IS_TMP_VAR) {
30653
      /* pass */
30654
2.22k
    } else if (IS_VAR == IS_CONST) {
30655
0
      Z_TRY_ADDREF_P(expr_ptr);
30656
2.22k
    } else if (IS_VAR == IS_CV) {
30657
0
      ZVAL_DEREF(expr_ptr);
30658
0
      Z_TRY_ADDREF_P(expr_ptr);
30659
2.22k
    } else /* if (IS_VAR == IS_VAR) */ {
30660
2.22k
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
30661
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
30662
30663
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
30664
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30665
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
30666
0
          expr_ptr = &new_expr;
30667
0
          efree_size(ref, sizeof(zend_reference));
30668
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
30669
0
          Z_ADDREF_P(expr_ptr);
30670
0
        }
30671
0
      }
30672
2.22k
    }
30673
2.22k
  }
30674
30675
2.27k
  if (IS_UNUSED != IS_UNUSED) {
30676
0
    zval *offset = NULL;
30677
0
    zend_string *str;
30678
0
    zend_ulong hval;
30679
30680
0
add_again:
30681
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
30682
0
      str = Z_STR_P(offset);
30683
0
      if (IS_UNUSED != IS_CONST) {
30684
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
30685
0
          goto num_index;
30686
0
        }
30687
0
      }
30688
0
str_index:
30689
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
30690
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
30691
0
      hval = Z_LVAL_P(offset);
30692
0
num_index:
30693
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
30694
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
30695
0
      offset = Z_REFVAL_P(offset);
30696
0
      goto add_again;
30697
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
30698
0
      str = ZSTR_EMPTY_ALLOC();
30699
0
      goto str_index;
30700
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
30701
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
30702
0
      goto num_index;
30703
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
30704
0
      hval = 0;
30705
0
      goto num_index;
30706
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
30707
0
      hval = 1;
30708
0
      goto num_index;
30709
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
30710
0
      zend_use_resource_as_offset(offset);
30711
0
      hval = Z_RES_HANDLE_P(offset);
30712
0
      goto num_index;
30713
0
    } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
30714
0
      ZVAL_UNDEFINED_OP2();
30715
0
      str = ZSTR_EMPTY_ALLOC();
30716
0
      goto str_index;
30717
0
    } else {
30718
0
      zend_illegal_array_offset_access(offset);
30719
0
      zval_ptr_dtor_nogc(expr_ptr);
30720
0
    }
30721
30722
2.27k
  } else {
30723
2.27k
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
30724
5
      zend_cannot_add_element();
30725
5
      zval_ptr_dtor_nogc(expr_ptr);
30726
5
    }
30727
2.27k
  }
30728
2.27k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30729
2.27k
}
30730
30731
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30732
1.29k
{
30733
1.29k
  zval *array;
30734
1.29k
  uint32_t size;
30735
1.29k
  USE_OPLINE
30736
30737
1.29k
  SAVE_OPLINE();
30738
1.29k
  array = EX_VAR(opline->result.var);
30739
1.29k
  if (IS_VAR != IS_UNUSED) {
30740
1.29k
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
30741
1.29k
    ZVAL_ARR(array, zend_new_array(size));
30742
    /* Explicitly initialize array as not-packed if flag is set */
30743
1.29k
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
30744
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
30745
0
    }
30746
1.29k
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30747
1.29k
  } else {
30748
0
    ZVAL_ARR(array, zend_new_array(0));
30749
0
    ZEND_VM_NEXT_OPCODE();
30750
0
  }
30751
1.29k
}
30752
30753
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30754
607
{
30755
607
  USE_OPLINE
30756
607
  zval *var_ptr;
30757
30758
607
  var_ptr = EX_VAR(opline->op1.var);
30759
607
  if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
30760
68
    if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) {
30761
18
      ZVAL_UNREF(var_ptr);
30762
18
    }
30763
68
  }
30764
30765
607
  ZEND_VM_NEXT_OPCODE();
30766
607
}
30767
30768
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30769
118
{
30770
118
  USE_OPLINE
30771
30772
118
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
30773
30774
118
  SAVE_OPLINE();
30775
118
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
30776
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30777
0
  }
30778
30779
  /* Destroy the previously yielded value */
30780
118
  zval_ptr_dtor(&generator->value);
30781
30782
  /* Destroy the previously yielded key */
30783
118
  zval_ptr_dtor(&generator->key);
30784
30785
  /* Set the new yielded value */
30786
118
  if (IS_VAR != IS_UNUSED) {
30787
118
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
30788
      /* Constants and temporary variables aren't yieldable by reference,
30789
       * but we still allow them with a notice. */
30790
47
      if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
30791
0
        zval *value;
30792
30793
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30794
30795
0
        value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30796
0
        ZVAL_COPY_VALUE(&generator->value, value);
30797
0
        if (IS_VAR == IS_CONST) {
30798
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30799
0
            Z_ADDREF(generator->value);
30800
0
          }
30801
0
        }
30802
47
      } else {
30803
47
        zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30804
30805
        /* If a function call result is yielded and the function did
30806
         * not return by reference we throw a notice. */
30807
47
        do {
30808
47
          if (IS_VAR == IS_VAR) {
30809
47
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
30810
47
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
30811
47
             && !Z_ISREF_P(value_ptr)) {
30812
5
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30813
5
              ZVAL_COPY(&generator->value, value_ptr);
30814
5
              break;
30815
5
            }
30816
47
          }
30817
42
          if (Z_ISREF_P(value_ptr)) {
30818
35
            Z_ADDREF_P(value_ptr);
30819
35
          } else {
30820
7
            ZVAL_MAKE_REF_EX(value_ptr, 2);
30821
7
          }
30822
42
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
30823
42
        } while (0);
30824
30825
47
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30826
47
      }
30827
71
    } else {
30828
71
      zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30829
30830
      /* Consts, temporary variables and references need copying */
30831
71
      if (IS_VAR == IS_CONST) {
30832
0
        ZVAL_COPY_VALUE(&generator->value, value);
30833
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30834
0
          Z_ADDREF(generator->value);
30835
0
        }
30836
71
      } else if (IS_VAR == IS_TMP_VAR) {
30837
0
        ZVAL_COPY_VALUE(&generator->value, value);
30838
71
      } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
30839
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
30840
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30841
71
      } else {
30842
71
        ZVAL_COPY_VALUE(&generator->value, value);
30843
71
        if (IS_VAR == IS_CV) {
30844
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
30845
0
        }
30846
71
      }
30847
71
    }
30848
118
  } else {
30849
    /* If no value was specified yield null */
30850
0
    ZVAL_NULL(&generator->value);
30851
0
  }
30852
30853
  /* Set the new yielded key */
30854
118
  if (IS_UNUSED != IS_UNUSED) {
30855
0
    zval *key = NULL;
30856
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
30857
0
      key = Z_REFVAL_P(key);
30858
0
    }
30859
0
    ZVAL_COPY(&generator->key, key);
30860
30861
0
    if (Z_TYPE(generator->key) == IS_LONG
30862
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
30863
0
    ) {
30864
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
30865
0
    }
30866
118
  } else {
30867
    /* If no key was specified we use auto-increment keys */
30868
118
    generator->largest_used_integer_key++;
30869
118
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
30870
118
  }
30871
30872
118
  if (RETURN_VALUE_USED(opline)) {
30873
    /* If the return value of yield is used set the send
30874
     * target and initialize it to NULL */
30875
15
    generator->send_target = EX_VAR(opline->result.var);
30876
15
    ZVAL_NULL(generator->send_target);
30877
103
  } else {
30878
103
    generator->send_target = NULL;
30879
103
  }
30880
30881
  /* The GOTO VM uses a local opline variable. We need to set the opline
30882
   * variable in execute_data so we don't resume at an old position. */
30883
118
  SAVE_OPLINE();
30884
30885
118
  ZEND_VM_RETURN();
30886
118
}
30887
30888
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30889
4.00k
{
30890
4.00k
  USE_OPLINE
30891
4.00k
  zval *op1 = EX_VAR(opline->op1.var);
30892
30893
4.00k
  if (IS_VAR == IS_CV) {
30894
0
    if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
30895
0
      ZVAL_NEW_EMPTY_REF(op1);
30896
0
      Z_SET_REFCOUNT_P(op1, 2);
30897
0
      ZVAL_NULL(Z_REFVAL_P(op1));
30898
0
      ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30899
0
    } else {
30900
0
      if (Z_ISREF_P(op1)) {
30901
0
        Z_ADDREF_P(op1);
30902
0
      } else {
30903
0
        ZVAL_MAKE_REF_EX(op1, 2);
30904
0
      }
30905
0
      ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30906
0
    }
30907
4.00k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
30908
3.82k
    op1 = Z_INDIRECT_P(op1);
30909
3.82k
    if (EXPECTED(!Z_ISREF_P(op1))) {
30910
2.75k
      ZVAL_MAKE_REF_EX(op1, 2);
30911
2.75k
    } else {
30912
1.07k
      GC_ADDREF(Z_REF_P(op1));
30913
1.07k
    }
30914
3.82k
    ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30915
3.82k
  } else {
30916
175
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
30917
175
  }
30918
4.00k
  ZEND_VM_NEXT_OPCODE();
30919
4.00k
}
30920
30921
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30922
7
{
30923
7
  USE_OPLINE
30924
7
  zval *op1;
30925
7
  zend_string *type;
30926
30927
7
  SAVE_OPLINE();
30928
7
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30929
7
  type = zend_zval_get_legacy_type(op1);
30930
7
  if (EXPECTED(type)) {
30931
7
    ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
30932
7
  } else {
30933
0
    ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
30934
0
  }
30935
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30936
7
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30937
7
}
30938
30939
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30940
75
{
30941
75
  USE_OPLINE
30942
75
  zval *varptr, *arg;
30943
75
  uint32_t arg_num = opline->op2.num;
30944
30945
75
  if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30946
0
    ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30947
0
  }
30948
30949
75
  varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30950
75
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30951
30952
75
  if (IS_VAR == IS_CV) {
30953
0
    ZVAL_COPY(arg, varptr);
30954
75
  } else /* if (IS_VAR == IS_VAR) */ {
30955
75
    ZVAL_COPY_VALUE(arg, varptr);
30956
75
  }
30957
30958
75
  ZEND_VM_NEXT_OPCODE();
30959
75
}
30960
30961
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30962
0
{
30963
0
  USE_OPLINE
30964
0
  zval *op1, *op2;
30965
0
  bool result;
30966
30967
0
  SAVE_OPLINE();
30968
0
  op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30969
0
  op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30970
0
  result = fast_is_identical_function(op1, op2);
30971
30972
0
  ZEND_VM_SMART_BRANCH(result, 1);
30973
0
}
30974
30975
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30976
0
{
30977
0
  USE_OPLINE
30978
0
  zval *object;
30979
0
  zval *property;
30980
0
  zval *value;
30981
0
  zval *zptr;
30982
0
  void *_cache_slot[3] = {0};
30983
0
  void **cache_slot;
30984
0
  zend_property_info *prop_info;
30985
0
  zend_object *zobj;
30986
0
  zend_string *name, *tmp_name;
30987
30988
0
  SAVE_OPLINE();
30989
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30990
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30991
30992
0
  do {
30993
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30994
30995
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30996
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30997
0
        object = Z_REFVAL_P(object);
30998
0
        goto assign_op_object;
30999
0
      }
31000
0
      if (IS_VAR == IS_CV
31001
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31002
0
        ZVAL_UNDEFINED_OP1();
31003
0
      }
31004
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31005
0
      break;
31006
0
    }
31007
31008
0
assign_op_object:
31009
    /* here we are sure we are dealing with an object */
31010
0
    zobj = Z_OBJ_P(object);
31011
0
    if (IS_CV == IS_CONST) {
31012
0
      name = Z_STR_P(property);
31013
0
    } else {
31014
0
      name = zval_try_get_tmp_string(property, &tmp_name);
31015
0
      if (UNEXPECTED(!name)) {
31016
0
        UNDEF_RESULT();
31017
0
        break;
31018
0
      }
31019
0
    }
31020
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
31021
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31022
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31023
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31024
0
          ZVAL_NULL(EX_VAR(opline->result.var));
31025
0
        }
31026
0
      } else {
31027
0
        zend_reference *ref;
31028
31029
0
        do {
31030
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
31031
0
            ref = Z_REF_P(zptr);
31032
0
            zptr = Z_REFVAL_P(zptr);
31033
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
31034
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
31035
0
              break;
31036
0
            }
31037
0
          }
31038
31039
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
31040
0
          if (prop_info) {
31041
            /* special case for typed properties */
31042
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
31043
0
          } else {
31044
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
31045
0
          }
31046
0
        } while (0);
31047
31048
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31049
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
31050
0
        }
31051
0
      }
31052
0
    } else {
31053
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
31054
0
    }
31055
0
    if (IS_CV != IS_CONST) {
31056
0
      zend_tmp_string_release(tmp_name);
31057
0
    }
31058
0
  } while (0);
31059
31060
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31061
31062
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31063
  /* assign_obj has two opcodes! */
31064
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31065
0
}
31066
31067
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
31068
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31069
0
{
31070
0
  USE_OPLINE
31071
0
  zval *var_ptr;
31072
0
  zval *value, *container, *dim;
31073
0
  HashTable *ht;
31074
31075
0
  SAVE_OPLINE();
31076
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31077
31078
0
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
31079
0
assign_dim_op_array:
31080
0
    SEPARATE_ARRAY(container);
31081
0
    ht = Z_ARRVAL_P(container);
31082
0
assign_dim_op_new_array:
31083
0
    dim = EX_VAR(opline->op2.var);
31084
0
    if (IS_CV == IS_UNUSED) {
31085
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
31086
0
      if (UNEXPECTED(!var_ptr)) {
31087
0
        zend_cannot_add_element();
31088
0
        goto assign_dim_op_ret_null;
31089
0
      }
31090
0
    } else {
31091
0
      if (IS_CV == IS_CONST) {
31092
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
31093
0
      } else {
31094
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
31095
0
      }
31096
0
      if (UNEXPECTED(!var_ptr)) {
31097
0
        goto assign_dim_op_ret_null;
31098
0
      }
31099
0
    }
31100
31101
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
31102
31103
0
    do {
31104
0
      if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
31105
0
        zend_reference *ref = Z_REF_P(var_ptr);
31106
0
        var_ptr = Z_REFVAL_P(var_ptr);
31107
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
31108
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
31109
0
          break;
31110
0
        }
31111
0
      }
31112
0
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
31113
0
    } while (0);
31114
31115
0
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31116
0
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
31117
0
    }
31118
0
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31119
0
  } else {
31120
0
    if (EXPECTED(Z_ISREF_P(container))) {
31121
0
      container = Z_REFVAL_P(container);
31122
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
31123
0
        goto assign_dim_op_array;
31124
0
      }
31125
0
    }
31126
31127
0
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
31128
0
      zend_object *obj = Z_OBJ_P(container);
31129
31130
0
      dim = EX_VAR(opline->op2.var);
31131
0
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31132
0
        dim++;
31133
0
      }
31134
0
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
31135
0
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
31136
0
      uint8_t old_type;
31137
31138
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
31139
0
        ZVAL_UNDEFINED_OP1();
31140
0
      }
31141
0
      ht = zend_new_array(8);
31142
0
      old_type = Z_TYPE_P(container);
31143
0
      ZVAL_ARR(container, ht);
31144
0
      if (UNEXPECTED(old_type == IS_FALSE)) {
31145
0
        GC_ADDREF(ht);
31146
0
        zend_false_to_array_deprecated();
31147
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31148
0
          zend_array_destroy(ht);
31149
0
          goto assign_dim_op_ret_null;
31150
0
        }
31151
0
      }
31152
0
      goto assign_dim_op_new_array;
31153
0
    } else {
31154
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31155
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
31156
0
assign_dim_op_ret_null:
31157
0
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31158
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31159
0
        ZVAL_NULL(EX_VAR(opline->result.var));
31160
0
      }
31161
0
    }
31162
0
  }
31163
31164
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31165
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31166
0
}
31167
31168
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31169
4.05k
{
31170
4.05k
  USE_OPLINE
31171
4.05k
  zval *var_ptr;
31172
4.05k
  zval *value;
31173
31174
4.05k
  SAVE_OPLINE();
31175
4.05k
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31176
4.05k
  var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31177
31178
4.05k
  do {
31179
4.05k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
31180
103
      zend_reference *ref = Z_REF_P(var_ptr);
31181
103
      var_ptr = Z_REFVAL_P(var_ptr);
31182
103
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
31183
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
31184
0
        break;
31185
0
      }
31186
103
    }
31187
4.05k
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
31188
4.05k
  } while (0);
31189
31190
4.05k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31191
3.20k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
31192
3.20k
  }
31193
31194
4.05k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31195
4.05k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31196
4.05k
}
31197
31198
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31199
0
{
31200
0
  USE_OPLINE
31201
0
  zval *object;
31202
0
  zval *property;
31203
0
  zval *zptr;
31204
0
  void *_cache_slot[3] = {0};
31205
0
  void **cache_slot;
31206
0
  zend_property_info *prop_info;
31207
0
  zend_object *zobj;
31208
0
  zend_string *name, *tmp_name;
31209
31210
0
  SAVE_OPLINE();
31211
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31212
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31213
31214
0
  do {
31215
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31216
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31217
0
        object = Z_REFVAL_P(object);
31218
0
        goto pre_incdec_object;
31219
0
      }
31220
0
      if (IS_VAR == IS_CV
31221
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31222
0
        ZVAL_UNDEFINED_OP1();
31223
0
      }
31224
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31225
0
      break;
31226
0
    }
31227
31228
0
pre_incdec_object:
31229
    /* here we are sure we are dealing with an object */
31230
0
    zobj = Z_OBJ_P(object);
31231
0
    if (IS_CV == IS_CONST) {
31232
0
      name = Z_STR_P(property);
31233
0
    } else {
31234
0
      name = zval_try_get_tmp_string(property, &tmp_name);
31235
0
      if (UNEXPECTED(!name)) {
31236
0
        UNDEF_RESULT();
31237
0
        break;
31238
0
      }
31239
0
    }
31240
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
31241
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31242
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31243
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31244
0
          ZVAL_NULL(EX_VAR(opline->result.var));
31245
0
        }
31246
0
      } else {
31247
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
31248
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
31249
0
      }
31250
0
    } else {
31251
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
31252
0
    }
31253
0
    if (IS_CV != IS_CONST) {
31254
0
      zend_tmp_string_release(tmp_name);
31255
0
    }
31256
0
  } while (0);
31257
31258
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31259
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31260
0
}
31261
31262
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31263
0
{
31264
0
  USE_OPLINE
31265
0
  zval *object;
31266
0
  zval *property;
31267
0
  zval *zptr;
31268
0
  void *_cache_slot[3] = {0};
31269
0
  void **cache_slot;
31270
0
  zend_property_info *prop_info;
31271
0
  zend_object *zobj;
31272
0
  zend_string *name, *tmp_name;
31273
31274
0
  SAVE_OPLINE();
31275
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31276
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31277
31278
0
  do {
31279
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31280
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31281
0
        object = Z_REFVAL_P(object);
31282
0
        goto post_incdec_object;
31283
0
      }
31284
0
      if (IS_VAR == IS_CV
31285
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31286
0
        ZVAL_UNDEFINED_OP1();
31287
0
      }
31288
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31289
0
      break;
31290
0
    }
31291
31292
0
post_incdec_object:
31293
    /* here we are sure we are dealing with an object */
31294
0
    zobj = Z_OBJ_P(object);
31295
0
    if (IS_CV == IS_CONST) {
31296
0
      name = Z_STR_P(property);
31297
0
    } else {
31298
0
      name = zval_try_get_tmp_string(property, &tmp_name);
31299
0
      if (UNEXPECTED(!name)) {
31300
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
31301
0
        break;
31302
0
      }
31303
0
    }
31304
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
31305
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31306
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31307
0
        ZVAL_NULL(EX_VAR(opline->result.var));
31308
0
      } else {
31309
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
31310
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
31311
0
      }
31312
0
    } else {
31313
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
31314
0
    }
31315
0
    if (IS_CV != IS_CONST) {
31316
0
      zend_tmp_string_release(tmp_name);
31317
0
    }
31318
0
  } while (0);
31319
31320
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31321
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31322
0
}
31323
31324
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31325
372
{
31326
372
  USE_OPLINE
31327
372
  zval *container;
31328
31329
372
  SAVE_OPLINE();
31330
372
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31331
372
  zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31332
31333
372
  if (IS_VAR == IS_VAR) {
31334
372
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31335
372
  }
31336
372
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31337
372
}
31338
31339
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31340
0
{
31341
0
  USE_OPLINE
31342
0
  zval *container;
31343
31344
0
  SAVE_OPLINE();
31345
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31346
0
  zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31347
31348
0
  if (IS_VAR == IS_VAR) {
31349
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31350
0
  }
31351
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31352
0
}
31353
31354
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31355
0
{
31356
#if 0
31357
  USE_OPLINE
31358
#endif
31359
31360
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
31361
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
31362
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31363
0
    }
31364
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31365
0
  } else {
31366
0
    if (IS_CV == IS_UNUSED) {
31367
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31368
0
    }
31369
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31370
0
  }
31371
0
}
31372
31373
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31374
0
{
31375
0
  USE_OPLINE
31376
0
  zval *container;
31377
31378
0
  SAVE_OPLINE();
31379
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31380
0
  zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31381
31382
0
  if (IS_VAR == IS_VAR) {
31383
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31384
0
  }
31385
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31386
0
}
31387
31388
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31389
26
{
31390
26
  USE_OPLINE
31391
26
  zval *property, *container, *result;
31392
31393
26
  SAVE_OPLINE();
31394
31395
26
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31396
26
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31397
26
  result = EX_VAR(opline->result.var);
31398
26
  zend_fetch_property_address(
31399
26
    result, container, IS_VAR, property, IS_CV,
31400
26
    ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
31401
26
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
31402
31403
26
  if (IS_VAR == IS_VAR) {
31404
26
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31405
26
  }
31406
26
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31407
26
}
31408
31409
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31410
0
{
31411
0
  USE_OPLINE
31412
0
  zval *property, *container, *result;
31413
31414
0
  SAVE_OPLINE();
31415
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31416
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31417
0
  result = EX_VAR(opline->result.var);
31418
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);
31419
31420
0
  if (IS_VAR == IS_VAR) {
31421
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31422
0
  }
31423
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31424
0
}
31425
31426
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31427
0
{
31428
#if 0
31429
  USE_OPLINE
31430
#endif
31431
31432
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
31433
    /* Behave like FETCH_OBJ_W */
31434
0
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
31435
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31436
0
    }
31437
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31438
0
  } else {
31439
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31440
0
  }
31441
0
}
31442
31443
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31444
0
{
31445
0
  USE_OPLINE
31446
0
  zval *container, *property, *result;
31447
31448
0
  SAVE_OPLINE();
31449
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31450
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31451
0
  result = EX_VAR(opline->result.var);
31452
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);
31453
31454
0
  if (IS_VAR == IS_VAR) {
31455
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31456
0
  }
31457
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31458
0
}
31459
31460
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31461
0
{
31462
0
  USE_OPLINE
31463
0
  zval *container, *dim;
31464
31465
0
  SAVE_OPLINE();
31466
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31467
0
  dim = EX_VAR(opline->op2.var);
31468
31469
0
  if (IS_VAR == IS_VAR
31470
0
    && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
31471
0
    && UNEXPECTED(!Z_ISREF_P(container))
31472
0
  ) {
31473
0
    zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
31474
0
    zend_fetch_dimension_address_LIST_r(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
31475
0
  } else {
31476
0
    zend_fetch_dimension_address_W(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
31477
0
  }
31478
31479
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31480
0
}
31481
31482
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31483
2
{
31484
2
  USE_OPLINE
31485
2
  zval *object, *value, tmp;
31486
2
  zend_object *zobj;
31487
2
  zend_string *name, *tmp_name;
31488
2
  zend_refcounted *garbage = NULL;
31489
31490
2
  SAVE_OPLINE();
31491
2
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31492
2
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
31493
31494
2
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31495
2
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31496
0
      object = Z_REFVAL_P(object);
31497
0
      goto assign_object;
31498
0
    }
31499
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);
31500
2
    value = &EG(uninitialized_zval);
31501
2
    goto free_and_exit_assign_obj;
31502
2
  }
31503
31504
0
assign_object:
31505
0
  zobj = Z_OBJ_P(object);
31506
0
  if (IS_CV == IS_CONST) {
31507
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31508
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
31509
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31510
0
      zval *property_val;
31511
0
      zend_property_info *prop_info;
31512
31513
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31514
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31515
31516
0
assign_obj_simple:
31517
0
        property_val = OBJ_PROP(zobj, prop_offset);
31518
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
31519
0
          if (prop_info != NULL) {
31520
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31521
0
            goto free_and_exit_assign_obj;
31522
0
          } else {
31523
0
fast_assign_obj:
31524
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
31525
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31526
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
31527
0
            }
31528
0
            goto exit_assign_obj;
31529
0
          }
31530
0
        }
31531
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31532
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31533
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31534
0
          zobj = zend_lazy_object_init(zobj);
31535
0
          if (!zobj) {
31536
0
            value = &EG(uninitialized_zval);
31537
0
            goto free_and_exit_assign_obj;
31538
0
          }
31539
0
        }
31540
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31541
0
          rebuild_object_properties_internal(zobj);
31542
0
        }
31543
0
        if (EXPECTED(zobj->properties != NULL)) {
31544
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31545
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31546
0
              GC_DELREF(zobj->properties);
31547
0
            }
31548
0
            zobj->properties = zend_array_dup(zobj->properties);
31549
0
          }
31550
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
31551
0
          if (property_val) {
31552
0
            goto fast_assign_obj;
31553
0
          }
31554
0
        }
31555
31556
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31557
0
          if (IS_CONST == IS_CONST) {
31558
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31559
0
              Z_ADDREF_P(value);
31560
0
            }
31561
0
          } else if (IS_CONST != IS_TMP_VAR) {
31562
0
            if (Z_ISREF_P(value)) {
31563
0
              if (IS_CONST == IS_VAR) {
31564
0
                zend_reference *ref = Z_REF_P(value);
31565
0
                if (GC_DELREF(ref) == 0) {
31566
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31567
0
                  efree_size(ref, sizeof(zend_reference));
31568
0
                  value = &tmp;
31569
0
                } else {
31570
0
                  value = Z_REFVAL_P(value);
31571
0
                  Z_TRY_ADDREF_P(value);
31572
0
                }
31573
0
              } else {
31574
0
                value = Z_REFVAL_P(value);
31575
0
                Z_TRY_ADDREF_P(value);
31576
0
              }
31577
0
            } else if (IS_CONST == IS_CV) {
31578
0
              Z_TRY_ADDREF_P(value);
31579
0
            }
31580
0
          }
31581
0
          zend_hash_add_new(zobj->properties, name, value);
31582
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31583
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
31584
0
          }
31585
0
          goto exit_assign_obj;
31586
0
        }
31587
0
      } else {
31588
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31589
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31590
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
31591
0
          prop_offset = prop_info->offset;
31592
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31593
0
            prop_info = NULL;
31594
0
          }
31595
0
          goto assign_obj_simple;
31596
0
        }
31597
        /* Fall through to write_property for hooks. */
31598
0
      }
31599
0
    }
31600
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31601
0
  } else {
31602
0
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31603
0
    if (UNEXPECTED(!name)) {
31604
31605
0
      UNDEF_RESULT();
31606
0
      goto exit_assign_obj;
31607
0
    }
31608
0
  }
31609
31610
0
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
31611
0
    ZVAL_DEREF(value);
31612
0
  }
31613
31614
0
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31615
31616
0
  if (IS_CV != IS_CONST) {
31617
0
    zend_tmp_string_release(tmp_name);
31618
0
  }
31619
31620
2
free_and_exit_assign_obj:
31621
2
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31622
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31623
0
  }
31624
31625
2
exit_assign_obj:
31626
2
  if (garbage) {
31627
0
    GC_DTOR_NO_REF(garbage);
31628
0
  }
31629
31630
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31631
  /* assign_obj has two opcodes! */
31632
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31633
2
}
31634
31635
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31636
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31637
0
{
31638
0
  USE_OPLINE
31639
0
  zval *object, *value, tmp;
31640
0
  zend_object *zobj;
31641
0
  zend_string *name, *tmp_name;
31642
0
  zend_refcounted *garbage = NULL;
31643
31644
0
  SAVE_OPLINE();
31645
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31646
0
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31647
31648
0
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31649
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31650
0
      object = Z_REFVAL_P(object);
31651
0
      goto assign_object;
31652
0
    }
31653
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);
31654
0
    value = &EG(uninitialized_zval);
31655
0
    goto free_and_exit_assign_obj;
31656
0
  }
31657
31658
0
assign_object:
31659
0
  zobj = Z_OBJ_P(object);
31660
0
  if (IS_CV == IS_CONST) {
31661
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31662
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
31663
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31664
0
      zval *property_val;
31665
0
      zend_property_info *prop_info;
31666
31667
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31668
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31669
31670
0
assign_obj_simple:
31671
0
        property_val = OBJ_PROP(zobj, prop_offset);
31672
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
31673
0
          if (prop_info != NULL) {
31674
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31675
0
            goto free_and_exit_assign_obj;
31676
0
          } else {
31677
0
fast_assign_obj:
31678
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
31679
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31680
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
31681
0
            }
31682
0
            goto exit_assign_obj;
31683
0
          }
31684
0
        }
31685
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31686
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31687
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31688
0
          zobj = zend_lazy_object_init(zobj);
31689
0
          if (!zobj) {
31690
0
            value = &EG(uninitialized_zval);
31691
0
            goto free_and_exit_assign_obj;
31692
0
          }
31693
0
        }
31694
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31695
0
          rebuild_object_properties_internal(zobj);
31696
0
        }
31697
0
        if (EXPECTED(zobj->properties != NULL)) {
31698
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31699
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31700
0
              GC_DELREF(zobj->properties);
31701
0
            }
31702
0
            zobj->properties = zend_array_dup(zobj->properties);
31703
0
          }
31704
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
31705
0
          if (property_val) {
31706
0
            goto fast_assign_obj;
31707
0
          }
31708
0
        }
31709
31710
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31711
0
          if (IS_TMP_VAR == IS_CONST) {
31712
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31713
0
              Z_ADDREF_P(value);
31714
0
            }
31715
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
31716
0
            if (Z_ISREF_P(value)) {
31717
0
              if (IS_TMP_VAR == IS_VAR) {
31718
0
                zend_reference *ref = Z_REF_P(value);
31719
0
                if (GC_DELREF(ref) == 0) {
31720
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31721
0
                  efree_size(ref, sizeof(zend_reference));
31722
0
                  value = &tmp;
31723
0
                } else {
31724
0
                  value = Z_REFVAL_P(value);
31725
0
                  Z_TRY_ADDREF_P(value);
31726
0
                }
31727
0
              } else {
31728
0
                value = Z_REFVAL_P(value);
31729
0
                Z_TRY_ADDREF_P(value);
31730
0
              }
31731
0
            } else if (IS_TMP_VAR == IS_CV) {
31732
0
              Z_TRY_ADDREF_P(value);
31733
0
            }
31734
0
          }
31735
0
          zend_hash_add_new(zobj->properties, name, value);
31736
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31737
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
31738
0
          }
31739
0
          goto exit_assign_obj;
31740
0
        }
31741
0
      } else {
31742
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31743
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31744
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
31745
0
          prop_offset = prop_info->offset;
31746
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31747
0
            prop_info = NULL;
31748
0
          }
31749
0
          goto assign_obj_simple;
31750
0
        }
31751
        /* Fall through to write_property for hooks. */
31752
0
      }
31753
0
    }
31754
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31755
0
  } else {
31756
0
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31757
0
    if (UNEXPECTED(!name)) {
31758
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31759
0
      UNDEF_RESULT();
31760
0
      goto exit_assign_obj;
31761
0
    }
31762
0
  }
31763
31764
0
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
31765
0
    ZVAL_DEREF(value);
31766
0
  }
31767
31768
0
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31769
31770
0
  if (IS_CV != IS_CONST) {
31771
0
    zend_tmp_string_release(tmp_name);
31772
0
  }
31773
31774
0
free_and_exit_assign_obj:
31775
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31776
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31777
0
  }
31778
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31779
0
exit_assign_obj:
31780
0
  if (garbage) {
31781
0
    GC_DTOR_NO_REF(garbage);
31782
0
  }
31783
31784
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31785
  /* assign_obj has two opcodes! */
31786
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31787
0
}
31788
31789
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31790
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31791
0
{
31792
0
  USE_OPLINE
31793
0
  zval *object, *value, tmp;
31794
0
  zend_object *zobj;
31795
0
  zend_string *name, *tmp_name;
31796
0
  zend_refcounted *garbage = NULL;
31797
31798
0
  SAVE_OPLINE();
31799
0
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31800
0
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31801
31802
0
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31803
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31804
0
      object = Z_REFVAL_P(object);
31805
0
      goto assign_object;
31806
0
    }
31807
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);
31808
0
    value = &EG(uninitialized_zval);
31809
0
    goto free_and_exit_assign_obj;
31810
0
  }
31811
31812
0
assign_object:
31813
0
  zobj = Z_OBJ_P(object);
31814
0
  if (IS_CV == IS_CONST) {
31815
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31816
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
31817
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31818
0
      zval *property_val;
31819
0
      zend_property_info *prop_info;
31820
31821
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31822
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31823
31824
0
assign_obj_simple:
31825
0
        property_val = OBJ_PROP(zobj, prop_offset);
31826
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
31827
0
          if (prop_info != NULL) {
31828
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31829
0
            goto free_and_exit_assign_obj;
31830
0
          } else {
31831
0
fast_assign_obj:
31832
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
31833
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31834
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
31835
0
            }
31836
0
            goto exit_assign_obj;
31837
0
          }
31838
0
        }
31839
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31840
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31841
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31842
0
          zobj = zend_lazy_object_init(zobj);
31843
0
          if (!zobj) {
31844
0
            value = &EG(uninitialized_zval);
31845
0
            goto free_and_exit_assign_obj;
31846
0
          }
31847
0
        }
31848
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31849
0
          rebuild_object_properties_internal(zobj);
31850
0
        }
31851
0
        if (EXPECTED(zobj->properties != NULL)) {
31852
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31853
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31854
0
              GC_DELREF(zobj->properties);
31855
0
            }
31856
0
            zobj->properties = zend_array_dup(zobj->properties);
31857
0
          }
31858
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
31859
0
          if (property_val) {
31860
0
            goto fast_assign_obj;
31861
0
          }
31862
0
        }
31863
31864
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31865
0
          if (IS_VAR == IS_CONST) {
31866
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31867
0
              Z_ADDREF_P(value);
31868
0
            }
31869
0
          } else if (IS_VAR != IS_TMP_VAR) {
31870
0
            if (Z_ISREF_P(value)) {
31871
0
              if (IS_VAR == IS_VAR) {
31872
0
                zend_reference *ref = Z_REF_P(value);
31873
0
                if (GC_DELREF(ref) == 0) {
31874
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31875
0
                  efree_size(ref, sizeof(zend_reference));
31876
0
                  value = &tmp;
31877
0
                } else {
31878
0
                  value = Z_REFVAL_P(value);
31879
0
                  Z_TRY_ADDREF_P(value);
31880
0
                }
31881
0
              } else {
31882
0
                value = Z_REFVAL_P(value);
31883
0
                Z_TRY_ADDREF_P(value);
31884
0
              }
31885
0
            } else if (IS_VAR == IS_CV) {
31886
0
              Z_TRY_ADDREF_P(value);
31887
0
            }
31888
0
          }
31889
0
          zend_hash_add_new(zobj->properties, name, value);
31890
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31891
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
31892
0
          }
31893
0
          goto exit_assign_obj;
31894
0
        }
31895
0
      } else {
31896
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31897
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31898
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
31899
0
          prop_offset = prop_info->offset;
31900
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31901
0
            prop_info = NULL;
31902
0
          }
31903
0
          goto assign_obj_simple;
31904
0
        }
31905
        /* Fall through to write_property for hooks. */
31906
0
      }
31907
0
    }
31908
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31909
0
  } else {
31910
0
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31911
0
    if (UNEXPECTED(!name)) {
31912
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31913
0
      UNDEF_RESULT();
31914
0
      goto exit_assign_obj;
31915
0
    }
31916
0
  }
31917
31918
0
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
31919
0
    ZVAL_DEREF(value);
31920
0
  }
31921
31922
0
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31923
31924
0
  if (IS_CV != IS_CONST) {
31925
0
    zend_tmp_string_release(tmp_name);
31926
0
  }
31927
31928
0
free_and_exit_assign_obj:
31929
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31930
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31931
0
  }
31932
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31933
0
exit_assign_obj:
31934
0
  if (garbage) {
31935
0
    GC_DTOR_NO_REF(garbage);
31936
0
  }
31937
31938
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31939
  /* assign_obj has two opcodes! */
31940
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
31941
0
}
31942
31943
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31944
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31945
17
{
31946
17
  USE_OPLINE
31947
17
  zval *object, *value, tmp;
31948
17
  zend_object *zobj;
31949
17
  zend_string *name, *tmp_name;
31950
17
  zend_refcounted *garbage = NULL;
31951
31952
17
  SAVE_OPLINE();
31953
17
  object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31954
17
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
31955
31956
17
  if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31957
2
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31958
0
      object = Z_REFVAL_P(object);
31959
0
      goto assign_object;
31960
0
    }
31961
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);
31962
2
    value = &EG(uninitialized_zval);
31963
2
    goto free_and_exit_assign_obj;
31964
2
  }
31965
31966
15
assign_object:
31967
15
  zobj = Z_OBJ_P(object);
31968
15
  if (IS_CV == IS_CONST) {
31969
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31970
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
31971
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31972
0
      zval *property_val;
31973
0
      zend_property_info *prop_info;
31974
31975
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31976
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31977
31978
0
assign_obj_simple:
31979
0
        property_val = OBJ_PROP(zobj, prop_offset);
31980
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
31981
0
          if (prop_info != NULL) {
31982
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31983
0
            goto free_and_exit_assign_obj;
31984
0
          } else {
31985
0
fast_assign_obj:
31986
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31987
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31988
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
31989
0
            }
31990
0
            goto exit_assign_obj;
31991
0
          }
31992
0
        }
31993
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31994
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31995
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31996
0
          zobj = zend_lazy_object_init(zobj);
31997
0
          if (!zobj) {
31998
0
            value = &EG(uninitialized_zval);
31999
0
            goto free_and_exit_assign_obj;
32000
0
          }
32001
0
        }
32002
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
32003
0
          rebuild_object_properties_internal(zobj);
32004
0
        }
32005
0
        if (EXPECTED(zobj->properties != NULL)) {
32006
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
32007
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
32008
0
              GC_DELREF(zobj->properties);
32009
0
            }
32010
0
            zobj->properties = zend_array_dup(zobj->properties);
32011
0
          }
32012
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
32013
0
          if (property_val) {
32014
0
            goto fast_assign_obj;
32015
0
          }
32016
0
        }
32017
32018
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
32019
0
          if (IS_CV == IS_CONST) {
32020
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
32021
0
              Z_ADDREF_P(value);
32022
0
            }
32023
0
          } else if (IS_CV != IS_TMP_VAR) {
32024
0
            if (Z_ISREF_P(value)) {
32025
0
              if (IS_CV == IS_VAR) {
32026
0
                zend_reference *ref = Z_REF_P(value);
32027
0
                if (GC_DELREF(ref) == 0) {
32028
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
32029
0
                  efree_size(ref, sizeof(zend_reference));
32030
0
                  value = &tmp;
32031
0
                } else {
32032
0
                  value = Z_REFVAL_P(value);
32033
0
                  Z_TRY_ADDREF_P(value);
32034
0
                }
32035
0
              } else {
32036
0
                value = Z_REFVAL_P(value);
32037
0
                Z_TRY_ADDREF_P(value);
32038
0
              }
32039
0
            } else if (IS_CV == IS_CV) {
32040
0
              Z_TRY_ADDREF_P(value);
32041
0
            }
32042
0
          }
32043
0
          zend_hash_add_new(zobj->properties, name, value);
32044
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32045
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
32046
0
          }
32047
0
          goto exit_assign_obj;
32048
0
        }
32049
0
      } else {
32050
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
32051
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
32052
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
32053
0
          prop_offset = prop_info->offset;
32054
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
32055
0
            prop_info = NULL;
32056
0
          }
32057
0
          goto assign_obj_simple;
32058
0
        }
32059
        /* Fall through to write_property for hooks. */
32060
0
      }
32061
0
    }
32062
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
32063
15
  } else {
32064
15
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
32065
15
    if (UNEXPECTED(!name)) {
32066
32067
0
      UNDEF_RESULT();
32068
0
      goto exit_assign_obj;
32069
0
    }
32070
15
  }
32071
32072
15
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
32073
15
    ZVAL_DEREF(value);
32074
15
  }
32075
32076
15
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
32077
32078
15
  if (IS_CV != IS_CONST) {
32079
15
    zend_tmp_string_release(tmp_name);
32080
15
  }
32081
32082
17
free_and_exit_assign_obj:
32083
17
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
32084
17
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
32085
17
  }
32086
32087
17
exit_assign_obj:
32088
17
  if (garbage) {
32089
0
    GC_DTOR_NO_REF(garbage);
32090
0
  }
32091
32092
17
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32093
  /* assign_obj has two opcodes! */
32094
17
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32095
17
}
32096
32097
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
32098
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32099
1.16k
{
32100
1.16k
  USE_OPLINE
32101
1.16k
  zval *object_ptr, *orig_object_ptr;
32102
1.16k
  zval *value;
32103
1.16k
  zval *variable_ptr;
32104
1.16k
  zval *dim;
32105
1.16k
  zend_refcounted *garbage = NULL;
32106
32107
1.16k
  SAVE_OPLINE();
32108
1.16k
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32109
32110
1.16k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32111
1.15k
try_assign_dim_array:
32112
1.15k
    SEPARATE_ARRAY(object_ptr);
32113
1.15k
    if (IS_CV == IS_UNUSED) {
32114
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
32115
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32116
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
32117
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32118
0
          GC_ADDREF(ht);
32119
0
        }
32120
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32121
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32122
0
          zend_array_destroy(ht);
32123
0
          goto assign_dim_error;
32124
0
        }
32125
0
      }
32126
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
32127
0
        ZVAL_DEREF(value);
32128
0
      }
32129
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32130
0
      if (UNEXPECTED(value == NULL)) {
32131
0
        zend_cannot_add_element();
32132
0
        goto assign_dim_error;
32133
0
      } else if (IS_CONST == IS_CV) {
32134
0
        if (Z_REFCOUNTED_P(value)) {
32135
0
          Z_ADDREF_P(value);
32136
0
        }
32137
0
      } else if (IS_CONST == IS_VAR) {
32138
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
32139
0
        if (Z_ISREF_P(free_op_data)) {
32140
0
          if (Z_REFCOUNTED_P(value)) {
32141
0
            Z_ADDREF_P(value);
32142
0
          }
32143
0
          zval_ptr_dtor_nogc(free_op_data);
32144
0
        }
32145
0
      } else if (IS_CONST == IS_CONST) {
32146
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32147
0
          Z_ADDREF_P(value);
32148
0
        }
32149
0
      }
32150
1.15k
    } else {
32151
1.15k
      dim = EX_VAR(opline->op2.var);
32152
1.15k
      if (IS_CV == IS_CONST) {
32153
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32154
1.15k
      } else {
32155
1.15k
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32156
1.15k
      }
32157
1.15k
      if (UNEXPECTED(variable_ptr == NULL)) {
32158
0
        goto assign_dim_error;
32159
0
      }
32160
1.15k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
32161
1.15k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
32162
1.15k
    }
32163
1.15k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32164
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32165
0
    }
32166
1.15k
    if (garbage) {
32167
0
      GC_DTOR_NO_REF(garbage);
32168
0
    }
32169
1.15k
  } else {
32170
109
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
32171
0
      object_ptr = Z_REFVAL_P(object_ptr);
32172
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32173
0
        goto try_assign_dim_array;
32174
0
      }
32175
0
    }
32176
109
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32177
5
      zend_object *obj = Z_OBJ_P(object_ptr);
32178
32179
5
      GC_ADDREF(obj);
32180
5
      dim = EX_VAR(opline->op2.var);
32181
5
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32182
0
        dim = ZVAL_UNDEFINED_OP2();
32183
5
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32184
0
        dim++;
32185
0
      }
32186
32187
5
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
32188
5
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32189
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32190
5
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
32191
0
        ZVAL_DEREF(value);
32192
0
      }
32193
32194
5
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32195
32196
5
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32197
0
        zend_objects_store_del(obj);
32198
0
      }
32199
104
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32200
0
      if (IS_CV == IS_UNUSED) {
32201
0
        zend_use_new_element_for_string();
32202
32203
0
        UNDEF_RESULT();
32204
0
      } else {
32205
0
        dim = EX_VAR(opline->op2.var);
32206
0
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
32207
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32208
32209
0
      }
32210
104
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32211
104
      if (Z_ISREF_P(orig_object_ptr)
32212
104
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32213
104
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32214
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32215
32216
0
        UNDEF_RESULT();
32217
104
      } else {
32218
104
        HashTable *ht = zend_new_array(8);
32219
104
        uint8_t old_type = Z_TYPE_P(object_ptr);
32220
32221
104
        ZVAL_ARR(object_ptr, ht);
32222
104
        if (UNEXPECTED(old_type == IS_FALSE)) {
32223
0
          GC_ADDREF(ht);
32224
0
          zend_false_to_array_deprecated();
32225
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32226
0
            zend_array_destroy(ht);
32227
0
            goto assign_dim_error;
32228
0
          }
32229
0
        }
32230
104
        goto try_assign_dim_array;
32231
104
      }
32232
104
    } else {
32233
0
      zend_use_scalar_as_array();
32234
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32235
0
assign_dim_error:
32236
32237
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32238
0
        ZVAL_NULL(EX_VAR(opline->result.var));
32239
0
      }
32240
0
    }
32241
109
  }
32242
1.16k
  if (IS_CV != IS_UNUSED) {
32243
32244
1.16k
  }
32245
1.16k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32246
  /* assign_dim has two opcodes! */
32247
1.16k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32248
1.16k
}
32249
32250
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32251
19
{
32252
19
  USE_OPLINE
32253
19
  zval *object_ptr, *orig_object_ptr;
32254
19
  zval *value;
32255
19
  zval *variable_ptr;
32256
19
  zval *dim;
32257
19
  zend_refcounted *garbage = NULL;
32258
32259
19
  SAVE_OPLINE();
32260
19
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32261
32262
19
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32263
19
try_assign_dim_array:
32264
19
    SEPARATE_ARRAY(object_ptr);
32265
19
    if (IS_CV == IS_UNUSED) {
32266
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32267
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32268
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
32269
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32270
0
          GC_ADDREF(ht);
32271
0
        }
32272
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32273
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32274
0
          zend_array_destroy(ht);
32275
0
          goto assign_dim_error;
32276
0
        }
32277
0
      }
32278
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
32279
0
        ZVAL_DEREF(value);
32280
0
      }
32281
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32282
0
      if (UNEXPECTED(value == NULL)) {
32283
0
        zend_cannot_add_element();
32284
0
        goto assign_dim_error;
32285
0
      } else if (IS_TMP_VAR == IS_CV) {
32286
0
        if (Z_REFCOUNTED_P(value)) {
32287
0
          Z_ADDREF_P(value);
32288
0
        }
32289
0
      } else if (IS_TMP_VAR == IS_VAR) {
32290
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
32291
0
        if (Z_ISREF_P(free_op_data)) {
32292
0
          if (Z_REFCOUNTED_P(value)) {
32293
0
            Z_ADDREF_P(value);
32294
0
          }
32295
0
          zval_ptr_dtor_nogc(free_op_data);
32296
0
        }
32297
0
      } else if (IS_TMP_VAR == IS_CONST) {
32298
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32299
0
          Z_ADDREF_P(value);
32300
0
        }
32301
0
      }
32302
19
    } else {
32303
19
      dim = EX_VAR(opline->op2.var);
32304
19
      if (IS_CV == IS_CONST) {
32305
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32306
19
      } else {
32307
19
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32308
19
      }
32309
19
      if (UNEXPECTED(variable_ptr == NULL)) {
32310
0
        goto assign_dim_error;
32311
0
      }
32312
19
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32313
19
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
32314
19
    }
32315
19
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32316
2
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32317
2
    }
32318
19
    if (garbage) {
32319
0
      GC_DTOR_NO_REF(garbage);
32320
0
    }
32321
19
  } else {
32322
5
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
32323
0
      object_ptr = Z_REFVAL_P(object_ptr);
32324
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32325
0
        goto try_assign_dim_array;
32326
0
      }
32327
0
    }
32328
5
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32329
0
      zend_object *obj = Z_OBJ_P(object_ptr);
32330
32331
0
      GC_ADDREF(obj);
32332
0
      dim = EX_VAR(opline->op2.var);
32333
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32334
0
        dim = ZVAL_UNDEFINED_OP2();
32335
0
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32336
0
        dim++;
32337
0
      }
32338
32339
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32340
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32341
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32342
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
32343
0
        ZVAL_DEREF(value);
32344
0
      }
32345
32346
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32347
32348
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32349
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32350
0
        zend_objects_store_del(obj);
32351
0
      }
32352
5
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32353
0
      if (IS_CV == IS_UNUSED) {
32354
0
        zend_use_new_element_for_string();
32355
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32356
0
        UNDEF_RESULT();
32357
0
      } else {
32358
0
        dim = EX_VAR(opline->op2.var);
32359
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32360
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32361
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32362
0
      }
32363
5
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32364
5
      if (Z_ISREF_P(orig_object_ptr)
32365
5
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32366
5
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32367
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32368
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32369
0
        UNDEF_RESULT();
32370
5
      } else {
32371
5
        HashTable *ht = zend_new_array(8);
32372
5
        uint8_t old_type = Z_TYPE_P(object_ptr);
32373
32374
5
        ZVAL_ARR(object_ptr, ht);
32375
5
        if (UNEXPECTED(old_type == IS_FALSE)) {
32376
0
          GC_ADDREF(ht);
32377
0
          zend_false_to_array_deprecated();
32378
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32379
0
            zend_array_destroy(ht);
32380
0
            goto assign_dim_error;
32381
0
          }
32382
0
        }
32383
5
        goto try_assign_dim_array;
32384
5
      }
32385
5
    } else {
32386
0
      zend_use_scalar_as_array();
32387
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32388
0
assign_dim_error:
32389
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32390
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32391
0
        ZVAL_NULL(EX_VAR(opline->result.var));
32392
0
      }
32393
0
    }
32394
5
  }
32395
19
  if (IS_CV != IS_UNUSED) {
32396
32397
19
  }
32398
19
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32399
  /* assign_dim has two opcodes! */
32400
19
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32401
19
}
32402
32403
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32404
965
{
32405
965
  USE_OPLINE
32406
965
  zval *object_ptr, *orig_object_ptr;
32407
965
  zval *value;
32408
965
  zval *variable_ptr;
32409
965
  zval *dim;
32410
965
  zend_refcounted *garbage = NULL;
32411
32412
965
  SAVE_OPLINE();
32413
965
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32414
32415
965
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32416
965
try_assign_dim_array:
32417
965
    SEPARATE_ARRAY(object_ptr);
32418
965
    if (IS_CV == IS_UNUSED) {
32419
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32420
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32421
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
32422
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32423
0
          GC_ADDREF(ht);
32424
0
        }
32425
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32426
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32427
0
          zend_array_destroy(ht);
32428
0
          goto assign_dim_error;
32429
0
        }
32430
0
      }
32431
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
32432
0
        ZVAL_DEREF(value);
32433
0
      }
32434
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32435
0
      if (UNEXPECTED(value == NULL)) {
32436
0
        zend_cannot_add_element();
32437
0
        goto assign_dim_error;
32438
0
      } else if (IS_VAR == IS_CV) {
32439
0
        if (Z_REFCOUNTED_P(value)) {
32440
0
          Z_ADDREF_P(value);
32441
0
        }
32442
0
      } else if (IS_VAR == IS_VAR) {
32443
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
32444
0
        if (Z_ISREF_P(free_op_data)) {
32445
0
          if (Z_REFCOUNTED_P(value)) {
32446
0
            Z_ADDREF_P(value);
32447
0
          }
32448
0
          zval_ptr_dtor_nogc(free_op_data);
32449
0
        }
32450
0
      } else if (IS_VAR == IS_CONST) {
32451
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32452
0
          Z_ADDREF_P(value);
32453
0
        }
32454
0
      }
32455
965
    } else {
32456
965
      dim = EX_VAR(opline->op2.var);
32457
965
      if (IS_CV == IS_CONST) {
32458
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32459
965
      } else {
32460
965
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32461
965
      }
32462
965
      if (UNEXPECTED(variable_ptr == NULL)) {
32463
0
        goto assign_dim_error;
32464
0
      }
32465
965
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32466
965
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
32467
965
    }
32468
965
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32469
690
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32470
690
    }
32471
965
    if (garbage) {
32472
94
      GC_DTOR_NO_REF(garbage);
32473
94
    }
32474
965
  } else {
32475
143
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
32476
0
      object_ptr = Z_REFVAL_P(object_ptr);
32477
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32478
0
        goto try_assign_dim_array;
32479
0
      }
32480
0
    }
32481
143
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32482
0
      zend_object *obj = Z_OBJ_P(object_ptr);
32483
32484
0
      GC_ADDREF(obj);
32485
0
      dim = EX_VAR(opline->op2.var);
32486
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32487
0
        dim = ZVAL_UNDEFINED_OP2();
32488
0
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32489
0
        dim++;
32490
0
      }
32491
32492
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32493
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32494
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32495
0
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
32496
0
        ZVAL_DEREF(value);
32497
0
      }
32498
32499
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32500
32501
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32502
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32503
0
        zend_objects_store_del(obj);
32504
0
      }
32505
143
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32506
0
      if (IS_CV == IS_UNUSED) {
32507
0
        zend_use_new_element_for_string();
32508
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32509
0
        UNDEF_RESULT();
32510
0
      } else {
32511
0
        dim = EX_VAR(opline->op2.var);
32512
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32513
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32514
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32515
0
      }
32516
143
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32517
143
      if (Z_ISREF_P(orig_object_ptr)
32518
143
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32519
143
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32520
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32521
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32522
0
        UNDEF_RESULT();
32523
143
      } else {
32524
143
        HashTable *ht = zend_new_array(8);
32525
143
        uint8_t old_type = Z_TYPE_P(object_ptr);
32526
32527
143
        ZVAL_ARR(object_ptr, ht);
32528
143
        if (UNEXPECTED(old_type == IS_FALSE)) {
32529
0
          GC_ADDREF(ht);
32530
0
          zend_false_to_array_deprecated();
32531
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32532
0
            zend_array_destroy(ht);
32533
0
            goto assign_dim_error;
32534
0
          }
32535
0
        }
32536
143
        goto try_assign_dim_array;
32537
143
      }
32538
143
    } else {
32539
0
      zend_use_scalar_as_array();
32540
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32541
0
assign_dim_error:
32542
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32543
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32544
0
        ZVAL_NULL(EX_VAR(opline->result.var));
32545
0
      }
32546
0
    }
32547
143
  }
32548
965
  if (IS_CV != IS_UNUSED) {
32549
32550
965
  }
32551
965
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32552
  /* assign_dim has two opcodes! */
32553
965
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32554
965
}
32555
32556
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32557
685
{
32558
685
  USE_OPLINE
32559
685
  zval *object_ptr, *orig_object_ptr;
32560
685
  zval *value;
32561
685
  zval *variable_ptr;
32562
685
  zval *dim;
32563
685
  zend_refcounted *garbage = NULL;
32564
32565
685
  SAVE_OPLINE();
32566
685
  orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32567
32568
685
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32569
685
try_assign_dim_array:
32570
685
    SEPARATE_ARRAY(object_ptr);
32571
685
    if (IS_CV == IS_UNUSED) {
32572
0
      value = EX_VAR((opline+1)->op1.var);
32573
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32574
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
32575
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32576
0
          GC_ADDREF(ht);
32577
0
        }
32578
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32579
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32580
0
          zend_array_destroy(ht);
32581
0
          goto assign_dim_error;
32582
0
        }
32583
0
      }
32584
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
32585
0
        ZVAL_DEREF(value);
32586
0
      }
32587
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32588
0
      if (UNEXPECTED(value == NULL)) {
32589
0
        zend_cannot_add_element();
32590
0
        goto assign_dim_error;
32591
0
      } else if (IS_CV == IS_CV) {
32592
0
        if (Z_REFCOUNTED_P(value)) {
32593
0
          Z_ADDREF_P(value);
32594
0
        }
32595
0
      } else if (IS_CV == IS_VAR) {
32596
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
32597
0
        if (Z_ISREF_P(free_op_data)) {
32598
0
          if (Z_REFCOUNTED_P(value)) {
32599
0
            Z_ADDREF_P(value);
32600
0
          }
32601
0
          zval_ptr_dtor_nogc(free_op_data);
32602
0
        }
32603
0
      } else if (IS_CV == IS_CONST) {
32604
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32605
0
          Z_ADDREF_P(value);
32606
0
        }
32607
0
      }
32608
685
    } else {
32609
685
      dim = EX_VAR(opline->op2.var);
32610
685
      if (IS_CV == IS_CONST) {
32611
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32612
685
      } else {
32613
685
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32614
685
      }
32615
685
      if (UNEXPECTED(variable_ptr == NULL)) {
32616
0
        goto assign_dim_error;
32617
0
      }
32618
685
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
32619
685
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32620
685
    }
32621
685
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32622
18
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32623
18
    }
32624
685
    if (garbage) {
32625
59
      GC_DTOR_NO_REF(garbage);
32626
59
    }
32627
685
  } else {
32628
187
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
32629
2
      object_ptr = Z_REFVAL_P(object_ptr);
32630
2
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32631
0
        goto try_assign_dim_array;
32632
0
      }
32633
2
    }
32634
187
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32635
0
      zend_object *obj = Z_OBJ_P(object_ptr);
32636
32637
0
      GC_ADDREF(obj);
32638
0
      dim = EX_VAR(opline->op2.var);
32639
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32640
0
        dim = ZVAL_UNDEFINED_OP2();
32641
0
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32642
0
        dim++;
32643
0
      }
32644
32645
0
      value = EX_VAR((opline+1)->op1.var);
32646
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32647
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32648
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
32649
0
        ZVAL_DEREF(value);
32650
0
      }
32651
32652
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32653
32654
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32655
0
        zend_objects_store_del(obj);
32656
0
      }
32657
187
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32658
0
      if (IS_CV == IS_UNUSED) {
32659
0
        zend_use_new_element_for_string();
32660
32661
0
        UNDEF_RESULT();
32662
0
      } else {
32663
0
        dim = EX_VAR(opline->op2.var);
32664
0
        value = EX_VAR((opline+1)->op1.var);
32665
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32666
32667
0
      }
32668
187
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32669
187
      if (Z_ISREF_P(orig_object_ptr)
32670
187
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32671
187
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32672
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32673
32674
0
        UNDEF_RESULT();
32675
187
      } else {
32676
187
        HashTable *ht = zend_new_array(8);
32677
187
        uint8_t old_type = Z_TYPE_P(object_ptr);
32678
32679
187
        ZVAL_ARR(object_ptr, ht);
32680
187
        if (UNEXPECTED(old_type == IS_FALSE)) {
32681
0
          GC_ADDREF(ht);
32682
0
          zend_false_to_array_deprecated();
32683
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32684
0
            zend_array_destroy(ht);
32685
0
            goto assign_dim_error;
32686
0
          }
32687
0
        }
32688
187
        goto try_assign_dim_array;
32689
187
      }
32690
187
    } else {
32691
0
      zend_use_scalar_as_array();
32692
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32693
0
assign_dim_error:
32694
32695
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32696
0
        ZVAL_NULL(EX_VAR(opline->result.var));
32697
0
      }
32698
0
    }
32699
187
  }
32700
685
  if (IS_CV != IS_UNUSED) {
32701
32702
685
  }
32703
685
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32704
  /* assign_dim has two opcodes! */
32705
685
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32706
685
}
32707
32708
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32709
778
{
32710
778
  USE_OPLINE
32711
778
  zval *value;
32712
778
  zval *variable_ptr;
32713
32714
778
  SAVE_OPLINE();
32715
778
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32716
778
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32717
32718
778
  if (0 || UNEXPECTED(0)) {
32719
0
    zend_refcounted *garbage = NULL;
32720
32721
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32722
0
    if (UNEXPECTED(0)) {
32723
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32724
0
    }
32725
0
    if (garbage) {
32726
0
      GC_DTOR_NO_REF(garbage);
32727
0
    }
32728
778
  } else {
32729
778
    value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32730
778
  }
32731
778
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32732
  /* zend_assign_to_variable() always takes care of op2, never free it! */
32733
32734
778
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32735
778
}
32736
32737
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32738
406
{
32739
406
  USE_OPLINE
32740
406
  zval *value;
32741
406
  zval *variable_ptr;
32742
32743
406
  SAVE_OPLINE();
32744
406
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32745
406
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32746
32747
406
  if (0 || UNEXPECTED(1)) {
32748
406
    zend_refcounted *garbage = NULL;
32749
32750
406
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32751
406
    if (UNEXPECTED(1)) {
32752
406
      ZVAL_COPY(EX_VAR(opline->result.var), value);
32753
406
    }
32754
406
    if (garbage) {
32755
39
      GC_DTOR_NO_REF(garbage);
32756
39
    }
32757
406
  } else {
32758
0
    value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32759
0
  }
32760
406
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32761
  /* zend_assign_to_variable() always takes care of op2, never free it! */
32762
32763
406
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32764
406
}
32765
32766
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32767
7.44k
{
32768
7.44k
  USE_OPLINE
32769
7.44k
  zval *variable_ptr;
32770
7.44k
  zval *value_ptr;
32771
7.44k
  zend_refcounted *garbage = NULL;
32772
32773
7.44k
  SAVE_OPLINE();
32774
7.44k
  value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
32775
7.44k
  variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32776
32777
7.44k
  if (IS_VAR == IS_VAR &&
32778
7.44k
             UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
32779
32780
0
    zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
32781
0
    variable_ptr = &EG(uninitialized_zval);
32782
7.44k
  } else if (IS_CV == IS_VAR &&
32783
7.44k
             opline->extended_value == ZEND_RETURNS_FUNCTION &&
32784
7.44k
         UNEXPECTED(!Z_ISREF_P(value_ptr))) {
32785
32786
0
    variable_ptr = zend_wrong_assign_to_variable_reference(
32787
0
      variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
32788
7.44k
  } else {
32789
7.44k
    zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
32790
7.44k
  }
32791
32792
7.44k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32793
451
    ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
32794
451
  }
32795
32796
7.44k
  if (garbage) {
32797
992
    GC_DTOR(garbage);
32798
992
  }
32799
32800
7.44k
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32801
7.44k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32802
7.44k
}
32803
32804
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32805
7
{
32806
7
  USE_OPLINE
32807
7
  zval *property, *container, *value_ptr;
32808
32809
7
  SAVE_OPLINE();
32810
32811
7
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32812
7
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32813
32814
7
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32815
32816
7
  if (1) {
32817
7
    if (IS_VAR == IS_UNUSED) {
32818
0
      if (IS_CV == IS_CONST) {
32819
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32820
0
      } else {
32821
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32822
0
      }
32823
7
    } else {
32824
7
      if (IS_CV == IS_CONST) {
32825
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32826
7
      } else {
32827
7
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32828
7
      }
32829
7
    }
32830
7
  } else {
32831
0
    zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32832
0
  }
32833
32834
7
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32835
32836
7
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32837
7
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32838
7
}
32839
32840
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
32841
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32842
0
{
32843
0
  USE_OPLINE
32844
0
  zval *property, *container, *value_ptr;
32845
32846
0
  SAVE_OPLINE();
32847
32848
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32849
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32850
32851
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
32852
32853
0
  if (1) {
32854
0
    if (IS_VAR == IS_UNUSED) {
32855
0
      if (IS_CV == IS_CONST) {
32856
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32857
0
      } else {
32858
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32859
0
      }
32860
0
    } else {
32861
0
      if (IS_CV == IS_CONST) {
32862
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32863
0
      } else {
32864
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32865
0
      }
32866
0
    }
32867
0
  } else {
32868
0
    zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32869
0
  }
32870
32871
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32872
32873
32874
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
32875
0
}
32876
32877
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
32878
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32879
157
{
32880
157
  USE_OPLINE
32881
157
  zval *function_name;
32882
157
  zend_class_entry *ce;
32883
157
  uint32_t call_info;
32884
157
  zend_function *fbc;
32885
157
  zend_execute_data *call;
32886
32887
157
  SAVE_OPLINE();
32888
32889
157
  if (IS_VAR == IS_CONST) {
32890
    /* no function found. try a static method in class */
32891
0
    ce = CACHED_PTR(opline->result.num);
32892
0
    if (UNEXPECTED(ce == NULL)) {
32893
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);
32894
0
      if (UNEXPECTED(ce == NULL)) {
32895
32896
0
        HANDLE_EXCEPTION();
32897
0
      }
32898
0
      if (IS_CV != IS_CONST) {
32899
0
        CACHE_PTR(opline->result.num, ce);
32900
0
      }
32901
0
    }
32902
157
  } else if (IS_VAR == IS_UNUSED) {
32903
0
    ce = zend_fetch_class(NULL, opline->op1.num);
32904
0
    if (UNEXPECTED(ce == NULL)) {
32905
32906
0
      HANDLE_EXCEPTION();
32907
0
    }
32908
157
  } else {
32909
157
    ce = Z_CE_P(EX_VAR(opline->op1.var));
32910
157
  }
32911
32912
157
  if (IS_VAR == IS_CONST &&
32913
157
      IS_CV == IS_CONST &&
32914
157
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
32915
    /* nothing to do */
32916
157
  } else if (IS_VAR != IS_CONST &&
32917
157
             IS_CV == IS_CONST &&
32918
157
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
32919
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
32920
157
  } else if (IS_CV != IS_UNUSED) {
32921
157
    function_name = EX_VAR(opline->op2.var);
32922
157
    if (IS_CV != IS_CONST) {
32923
157
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
32924
17
        do {
32925
17
          if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
32926
0
            function_name = Z_REFVAL_P(function_name);
32927
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
32928
0
              break;
32929
0
            }
32930
17
          } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
32931
7
            ZVAL_UNDEFINED_OP2();
32932
7
            if (UNEXPECTED(EG(exception) != NULL)) {
32933
0
              HANDLE_EXCEPTION();
32934
0
            }
32935
7
          }
32936
17
          zend_throw_error(NULL, "Method name must be a string");
32937
32938
17
          HANDLE_EXCEPTION();
32939
17
        } while (0);
32940
17
      }
32941
157
    }
32942
32943
140
    if (ce->get_static_method) {
32944
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
32945
140
    } else {
32946
140
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
32947
140
    }
32948
140
    if (UNEXPECTED(fbc == NULL)) {
32949
8
      if (EXPECTED(!EG(exception))) {
32950
8
        zend_undefined_method(ce, Z_STR_P(function_name));
32951
8
      }
32952
32953
8
      HANDLE_EXCEPTION();
32954
8
    }
32955
132
    if (IS_CV == IS_CONST &&
32956
132
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
32957
132
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
32958
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
32959
0
    }
32960
132
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32961
2
      init_func_run_time_cache(&fbc->op_array);
32962
2
    }
32963
132
    if (IS_CV != IS_CONST) {
32964
32965
132
    }
32966
132
  } else {
32967
0
    if (UNEXPECTED(ce->constructor == NULL)) {
32968
0
      zend_throw_error(NULL, "Cannot call constructor");
32969
0
      HANDLE_EXCEPTION();
32970
0
    }
32971
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)) {
32972
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
32973
0
      HANDLE_EXCEPTION();
32974
0
    }
32975
0
    fbc = ce->constructor;
32976
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32977
0
      init_func_run_time_cache(&fbc->op_array);
32978
0
    }
32979
0
  }
32980
32981
132
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
32982
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
32983
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
32984
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
32985
0
    } else {
32986
0
      zend_non_static_method_call(fbc);
32987
0
      HANDLE_EXCEPTION();
32988
0
    }
32989
132
  } else {
32990
    /* previous opcode is ZEND_FETCH_CLASS */
32991
132
    if (IS_VAR == IS_UNUSED
32992
132
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
32993
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
32994
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
32995
0
        ce = Z_OBJCE(EX(This));
32996
0
      } else {
32997
0
        ce = Z_CE(EX(This));
32998
0
      }
32999
0
    }
33000
132
    call_info = ZEND_CALL_NESTED_FUNCTION;
33001
132
  }
33002
33003
132
  call = zend_vm_stack_push_call_frame(call_info,
33004
132
    fbc, opline->extended_value, ce);
33005
132
  call->prev_execute_data = EX(call);
33006
132
  EX(call) = call;
33007
33008
132
  ZEND_VM_NEXT_OPCODE();
33009
132
}
33010
33011
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33012
0
{
33013
0
  USE_OPLINE
33014
0
  zval *expr_ptr, new_expr;
33015
33016
0
  SAVE_OPLINE();
33017
0
  if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
33018
0
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
33019
0
    expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33020
0
    if (Z_ISREF_P(expr_ptr)) {
33021
0
      Z_ADDREF_P(expr_ptr);
33022
0
    } else {
33023
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
33024
0
    }
33025
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33026
0
  } else {
33027
0
    expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33028
0
    if (IS_VAR == IS_TMP_VAR) {
33029
      /* pass */
33030
0
    } else if (IS_VAR == IS_CONST) {
33031
0
      Z_TRY_ADDREF_P(expr_ptr);
33032
0
    } else if (IS_VAR == IS_CV) {
33033
0
      ZVAL_DEREF(expr_ptr);
33034
0
      Z_TRY_ADDREF_P(expr_ptr);
33035
0
    } else /* if (IS_VAR == IS_VAR) */ {
33036
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
33037
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
33038
33039
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
33040
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
33041
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
33042
0
          expr_ptr = &new_expr;
33043
0
          efree_size(ref, sizeof(zend_reference));
33044
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
33045
0
          Z_ADDREF_P(expr_ptr);
33046
0
        }
33047
0
      }
33048
0
    }
33049
0
  }
33050
33051
0
  if (IS_CV != IS_UNUSED) {
33052
0
    zval *offset = EX_VAR(opline->op2.var);
33053
0
    zend_string *str;
33054
0
    zend_ulong hval;
33055
33056
0
add_again:
33057
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
33058
0
      str = Z_STR_P(offset);
33059
0
      if (IS_CV != IS_CONST) {
33060
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
33061
0
          goto num_index;
33062
0
        }
33063
0
      }
33064
0
str_index:
33065
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
33066
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
33067
0
      hval = Z_LVAL_P(offset);
33068
0
num_index:
33069
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
33070
0
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
33071
0
      offset = Z_REFVAL_P(offset);
33072
0
      goto add_again;
33073
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
33074
0
      str = ZSTR_EMPTY_ALLOC();
33075
0
      goto str_index;
33076
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
33077
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
33078
0
      goto num_index;
33079
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
33080
0
      hval = 0;
33081
0
      goto num_index;
33082
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
33083
0
      hval = 1;
33084
0
      goto num_index;
33085
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
33086
0
      zend_use_resource_as_offset(offset);
33087
0
      hval = Z_RES_HANDLE_P(offset);
33088
0
      goto num_index;
33089
0
    } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
33090
0
      ZVAL_UNDEFINED_OP2();
33091
0
      str = ZSTR_EMPTY_ALLOC();
33092
0
      goto str_index;
33093
0
    } else {
33094
0
      zend_illegal_array_offset_access(offset);
33095
0
      zval_ptr_dtor_nogc(expr_ptr);
33096
0
    }
33097
33098
0
  } else {
33099
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
33100
0
      zend_cannot_add_element();
33101
0
      zval_ptr_dtor_nogc(expr_ptr);
33102
0
    }
33103
0
  }
33104
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33105
0
}
33106
33107
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33108
0
{
33109
0
  zval *array;
33110
0
  uint32_t size;
33111
0
  USE_OPLINE
33112
33113
0
  SAVE_OPLINE();
33114
0
  array = EX_VAR(opline->result.var);
33115
0
  if (IS_VAR != IS_UNUSED) {
33116
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
33117
0
    ZVAL_ARR(array, zend_new_array(size));
33118
    /* Explicitly initialize array as not-packed if flag is set */
33119
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
33120
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
33121
0
    }
33122
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33123
0
  } else {
33124
0
    ZVAL_ARR(array, zend_new_array(0));
33125
0
    ZEND_VM_NEXT_OPCODE();
33126
0
  }
33127
0
}
33128
33129
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33130
155
{
33131
155
  USE_OPLINE
33132
155
  zval *container;
33133
155
  zval *offset;
33134
155
  zend_ulong hval;
33135
155
  zend_string *key;
33136
33137
155
  SAVE_OPLINE();
33138
155
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33139
155
  offset = EX_VAR(opline->op2.var);
33140
33141
155
  do {
33142
155
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
33143
40
      HashTable *ht;
33144
33145
40
unset_dim_array:
33146
40
      SEPARATE_ARRAY(container);
33147
40
      ht = Z_ARRVAL_P(container);
33148
40
offset_again:
33149
40
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
33150
18
        key = Z_STR_P(offset);
33151
18
        if (IS_CV != IS_CONST) {
33152
18
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
33153
0
            goto num_index_dim;
33154
0
          }
33155
18
        }
33156
20
str_index_dim:
33157
20
        ZEND_ASSERT(ht != &EG(symbol_table));
33158
20
        zend_hash_del(ht, key);
33159
22
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
33160
20
        hval = Z_LVAL_P(offset);
33161
20
num_index_dim:
33162
20
        zend_hash_index_del(ht, hval);
33163
20
      } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
33164
0
        offset = Z_REFVAL_P(offset);
33165
0
        goto offset_again;
33166
2
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
33167
0
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
33168
0
        goto num_index_dim;
33169
2
      } else if (Z_TYPE_P(offset) == IS_NULL) {
33170
0
        key = ZSTR_EMPTY_ALLOC();
33171
0
        goto str_index_dim;
33172
2
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
33173
0
        hval = 0;
33174
0
        goto num_index_dim;
33175
2
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
33176
0
        hval = 1;
33177
0
        goto num_index_dim;
33178
2
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
33179
0
        zend_use_resource_as_offset(offset);
33180
0
        hval = Z_RES_HANDLE_P(offset);
33181
0
        goto num_index_dim;
33182
2
      } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
33183
2
        ZVAL_UNDEFINED_OP2();
33184
2
        key = ZSTR_EMPTY_ALLOC();
33185
2
        goto str_index_dim;
33186
2
      } else {
33187
0
        zend_illegal_array_offset_unset(offset);
33188
0
      }
33189
40
      break;
33190
115
    } else if (Z_ISREF_P(container)) {
33191
0
      container = Z_REFVAL_P(container);
33192
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
33193
0
        goto unset_dim_array;
33194
0
      }
33195
0
    }
33196
115
    if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33197
0
      container = ZVAL_UNDEFINED_OP1();
33198
0
    }
33199
115
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
33200
2
      offset = ZVAL_UNDEFINED_OP2();
33201
2
    }
33202
115
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33203
109
      if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
33204
0
        offset++;
33205
0
      }
33206
109
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
33207
109
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
33208
0
      zend_throw_error(NULL, "Cannot unset string offsets");
33209
6
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
33210
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
33211
6
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
33212
0
      zend_false_to_array_deprecated();
33213
0
    }
33214
115
  } while (0);
33215
33216
155
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33217
155
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33218
155
}
33219
33220
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33221
0
{
33222
0
  USE_OPLINE
33223
0
  zval *container;
33224
0
  zval *offset;
33225
0
  zend_string *name, *tmp_name;
33226
33227
0
  SAVE_OPLINE();
33228
0
  container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33229
0
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
33230
33231
0
  do {
33232
0
    if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
33233
0
      if (Z_ISREF_P(container)) {
33234
0
        container = Z_REFVAL_P(container);
33235
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
33236
0
          if (IS_VAR == IS_CV
33237
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33238
0
            ZVAL_UNDEFINED_OP1();
33239
0
          }
33240
0
          break;
33241
0
        }
33242
0
      } else {
33243
0
        break;
33244
0
      }
33245
0
    }
33246
0
    if (IS_CV == IS_CONST) {
33247
0
      name = Z_STR_P(offset);
33248
0
    } else {
33249
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
33250
0
      if (UNEXPECTED(!name)) {
33251
0
        break;
33252
0
      }
33253
0
    }
33254
0
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
33255
0
    if (IS_CV != IS_CONST) {
33256
0
      zend_tmp_string_release(tmp_name);
33257
0
    }
33258
0
  } while (0);
33259
33260
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33261
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33262
0
}
33263
33264
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33265
15
{
33266
15
  USE_OPLINE
33267
33268
15
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
33269
33270
15
  SAVE_OPLINE();
33271
15
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
33272
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33273
0
  }
33274
33275
  /* Destroy the previously yielded value */
33276
15
  zval_ptr_dtor(&generator->value);
33277
33278
  /* Destroy the previously yielded key */
33279
15
  zval_ptr_dtor(&generator->key);
33280
33281
  /* Set the new yielded value */
33282
15
  if (IS_VAR != IS_UNUSED) {
33283
15
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
33284
      /* Constants and temporary variables aren't yieldable by reference,
33285
       * but we still allow them with a notice. */
33286
0
      if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
33287
0
        zval *value;
33288
33289
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33290
33291
0
        value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33292
0
        ZVAL_COPY_VALUE(&generator->value, value);
33293
0
        if (IS_VAR == IS_CONST) {
33294
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
33295
0
            Z_ADDREF(generator->value);
33296
0
          }
33297
0
        }
33298
0
      } else {
33299
0
        zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33300
33301
        /* If a function call result is yielded and the function did
33302
         * not return by reference we throw a notice. */
33303
0
        do {
33304
0
          if (IS_VAR == IS_VAR) {
33305
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
33306
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
33307
0
             && !Z_ISREF_P(value_ptr)) {
33308
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33309
0
              ZVAL_COPY(&generator->value, value_ptr);
33310
0
              break;
33311
0
            }
33312
0
          }
33313
0
          if (Z_ISREF_P(value_ptr)) {
33314
0
            Z_ADDREF_P(value_ptr);
33315
0
          } else {
33316
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
33317
0
          }
33318
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
33319
0
        } while (0);
33320
33321
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33322
0
      }
33323
15
    } else {
33324
15
      zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33325
33326
      /* Consts, temporary variables and references need copying */
33327
15
      if (IS_VAR == IS_CONST) {
33328
0
        ZVAL_COPY_VALUE(&generator->value, value);
33329
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
33330
0
          Z_ADDREF(generator->value);
33331
0
        }
33332
15
      } else if (IS_VAR == IS_TMP_VAR) {
33333
0
        ZVAL_COPY_VALUE(&generator->value, value);
33334
15
      } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
33335
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
33336
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33337
15
      } else {
33338
15
        ZVAL_COPY_VALUE(&generator->value, value);
33339
15
        if (IS_VAR == IS_CV) {
33340
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
33341
0
        }
33342
15
      }
33343
15
    }
33344
15
  } else {
33345
    /* If no value was specified yield null */
33346
0
    ZVAL_NULL(&generator->value);
33347
0
  }
33348
33349
  /* Set the new yielded key */
33350
15
  if (IS_CV != IS_UNUSED) {
33351
15
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
33352
15
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
33353
0
      key = Z_REFVAL_P(key);
33354
0
    }
33355
15
    ZVAL_COPY(&generator->key, key);
33356
33357
15
    if (Z_TYPE(generator->key) == IS_LONG
33358
15
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
33359
15
    ) {
33360
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
33361
0
    }
33362
15
  } else {
33363
    /* If no key was specified we use auto-increment keys */
33364
0
    generator->largest_used_integer_key++;
33365
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
33366
0
  }
33367
33368
15
  if (RETURN_VALUE_USED(opline)) {
33369
    /* If the return value of yield is used set the send
33370
     * target and initialize it to NULL */
33371
3
    generator->send_target = EX_VAR(opline->result.var);
33372
3
    ZVAL_NULL(generator->send_target);
33373
12
  } else {
33374
12
    generator->send_target = NULL;
33375
12
  }
33376
33377
  /* The GOTO VM uses a local opline variable. We need to set the opline
33378
   * variable in execute_data so we don't resume at an old position. */
33379
15
  SAVE_OPLINE();
33380
33381
15
  ZEND_VM_RETURN();
33382
15
}
33383
33384
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)
33385
3.32k
{
33386
3.32k
  USE_OPLINE
33387
3.32k
  zval *array;
33388
3.32k
  zval *value, *variable_ptr;
33389
3.32k
  uint32_t value_type;
33390
3.32k
  HashTable *fe_ht;
33391
3.32k
  HashPosition pos;
33392
33393
3.32k
  array = EX_VAR(opline->op1.var);
33394
3.32k
  SAVE_OPLINE();
33395
3.32k
  fe_ht = Z_ARRVAL_P(array);
33396
3.32k
  pos = Z_FE_POS_P(array);
33397
3.32k
  if (HT_IS_PACKED(fe_ht)) {
33398
3.30k
    value = fe_ht->arPacked + pos;
33399
3.30k
    while (1) {
33400
3.30k
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33401
        /* reached end of iteration */
33402
317
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33403
317
        ZEND_VM_CONTINUE();
33404
317
      }
33405
2.98k
      value_type = Z_TYPE_INFO_P(value);
33406
2.98k
      ZEND_ASSERT(value_type != IS_INDIRECT);
33407
2.98k
      if (EXPECTED(value_type != IS_UNDEF)) {
33408
2.98k
        break;
33409
2.98k
      }
33410
0
      pos++;
33411
0
      value++;
33412
0
    }
33413
2.98k
    Z_FE_POS_P(array) = pos + 1;
33414
2.98k
    if (0) {
33415
0
      ZVAL_LONG(EX_VAR(opline->result.var), pos);
33416
0
    }
33417
2.98k
  } else {
33418
25
    Bucket *p;
33419
33420
25
    p = fe_ht->arData + pos;
33421
25
    while (1) {
33422
25
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33423
        /* reached end of iteration */
33424
15
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33425
15
        ZEND_VM_CONTINUE();
33426
15
      }
33427
10
      pos++;
33428
10
      value = &p->val;
33429
10
      value_type = Z_TYPE_INFO_P(value);
33430
10
      ZEND_ASSERT(value_type != IS_INDIRECT);
33431
10
      if (EXPECTED(value_type != IS_UNDEF)) {
33432
10
        break;
33433
10
      }
33434
0
      p++;
33435
0
    }
33436
10
    Z_FE_POS_P(array) = pos;
33437
10
    if (0) {
33438
0
      if (!p->key) {
33439
0
        ZVAL_LONG(EX_VAR(opline->result.var), p->h);
33440
0
      } else {
33441
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
33442
0
      }
33443
0
    }
33444
10
  }
33445
33446
2.99k
  variable_ptr = EX_VAR(opline->op2.var);
33447
2.99k
  zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
33448
2.99k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33449
2.99k
}
33450
33451
33452
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)
33453
952
{
33454
952
  USE_OPLINE
33455
952
  zval *array;
33456
952
  zval *value, *variable_ptr;
33457
952
  uint32_t value_type;
33458
952
  HashTable *fe_ht;
33459
952
  HashPosition pos;
33460
33461
952
  array = EX_VAR(opline->op1.var);
33462
952
  SAVE_OPLINE();
33463
952
  fe_ht = Z_ARRVAL_P(array);
33464
952
  pos = Z_FE_POS_P(array);
33465
952
  if (HT_IS_PACKED(fe_ht)) {
33466
178
    value = fe_ht->arPacked + pos;
33467
178
    while (1) {
33468
178
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33469
        /* reached end of iteration */
33470
57
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33471
57
        ZEND_VM_CONTINUE();
33472
57
      }
33473
121
      value_type = Z_TYPE_INFO_P(value);
33474
121
      ZEND_ASSERT(value_type != IS_INDIRECT);
33475
121
      if (EXPECTED(value_type != IS_UNDEF)) {
33476
121
        break;
33477
121
      }
33478
0
      pos++;
33479
0
      value++;
33480
0
    }
33481
121
    Z_FE_POS_P(array) = pos + 1;
33482
121
    if (1) {
33483
121
      ZVAL_LONG(EX_VAR(opline->result.var), pos);
33484
121
    }
33485
774
  } else {
33486
774
    Bucket *p;
33487
33488
774
    p = fe_ht->arData + pos;
33489
774
    while (1) {
33490
774
      if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33491
        /* reached end of iteration */
33492
83
        ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33493
83
        ZEND_VM_CONTINUE();
33494
83
      }
33495
691
      pos++;
33496
691
      value = &p->val;
33497
691
      value_type = Z_TYPE_INFO_P(value);
33498
691
      ZEND_ASSERT(value_type != IS_INDIRECT);
33499
691
      if (EXPECTED(value_type != IS_UNDEF)) {
33500
691
        break;
33501
691
      }
33502
0
      p++;
33503
0
    }
33504
691
    Z_FE_POS_P(array) = pos;
33505
691
    if (1) {
33506
691
      if (!p->key) {
33507
16
        ZVAL_LONG(EX_VAR(opline->result.var), p->h);
33508
675
      } else {
33509
675
        ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
33510
675
      }
33511
691
    }
33512
691
  }
33513
33514
812
  variable_ptr = EX_VAR(opline->op2.var);
33515
812
  zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
33516
812
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33517
812
}
33518
33519
33520
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33521
0
{
33522
0
  USE_OPLINE
33523
0
  zval *obj;
33524
0
  zend_object *zobj;
33525
0
  zend_class_entry *ce, *scope;
33526
0
  zend_function *clone;
33527
0
  zend_object_clone_obj_t clone_call;
33528
33529
0
  SAVE_OPLINE();
33530
0
  obj = &EX(This);
33531
33532
  /* ZEND_CLONE also exists as the clone() function and both implementations must be kept in sync.
33533
   * The OPcode intentionally does not support a clone-with property list to keep it simple. */
33534
33535
0
  do {
33536
0
    if (IS_UNUSED == IS_CONST ||
33537
0
        (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
33538
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
33539
0
        obj = Z_REFVAL_P(obj);
33540
0
        if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
33541
0
          break;
33542
0
        }
33543
0
      }
33544
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
33545
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
33546
0
        ZVAL_UNDEFINED_OP1();
33547
0
        if (UNEXPECTED(EG(exception) != NULL)) {
33548
0
          HANDLE_EXCEPTION();
33549
0
        }
33550
0
      }
33551
0
      zend_type_error("clone(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(obj));
33552
33553
0
      HANDLE_EXCEPTION();
33554
0
    }
33555
0
  } while (0);
33556
33557
0
  zobj = Z_OBJ_P(obj);
33558
0
  ce = zobj->ce;
33559
0
  clone = ce->clone;
33560
0
  clone_call = zobj->handlers->clone_obj;
33561
0
  if (UNEXPECTED(clone_call == NULL)) {
33562
0
    zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
33563
33564
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
33565
0
    HANDLE_EXCEPTION();
33566
0
  }
33567
33568
0
  if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
33569
0
    scope = EX(func)->op_array.scope;
33570
0
    ZEND_ASSERT(!(clone->common.fn_flags & ZEND_ACC_PUBLIC));
33571
0
    if (!zend_check_method_accessible(clone, scope)) {
33572
0
      zend_bad_method_call(clone, clone->common.function_name, scope);
33573
33574
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
33575
0
      HANDLE_EXCEPTION();
33576
0
    }
33577
0
  }
33578
33579
0
  ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
33580
33581
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33582
0
}
33583
33584
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33585
446
{
33586
446
  uint32_t fetch_type;
33587
446
  zend_class_entry *called_scope, *scope;
33588
446
  USE_OPLINE
33589
33590
446
  if (IS_UNUSED != IS_UNUSED) {
33591
0
    SAVE_OPLINE();
33592
0
    zval *op = NULL;
33593
0
    if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
33594
0
      ZVAL_DEREF(op);
33595
0
      if (Z_TYPE_P(op) != IS_OBJECT) {
33596
0
        zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
33597
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33598
33599
0
        HANDLE_EXCEPTION();
33600
0
      }
33601
0
    }
33602
33603
0
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
33604
33605
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33606
0
  }
33607
33608
446
  fetch_type = opline->op1.num;
33609
446
  scope = EX(func)->op_array.scope;
33610
446
  if (UNEXPECTED(scope == NULL)) {
33611
20
    SAVE_OPLINE();
33612
20
    zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
33613
20
      fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
33614
20
      fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
33615
20
    ZVAL_UNDEF(EX_VAR(opline->result.var));
33616
20
    HANDLE_EXCEPTION();
33617
20
  }
33618
33619
426
  switch (fetch_type) {
33620
189
    case ZEND_FETCH_CLASS_SELF:
33621
189
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
33622
189
      break;
33623
5
    case ZEND_FETCH_CLASS_PARENT:
33624
5
      if (UNEXPECTED(scope->parent == NULL)) {
33625
5
        SAVE_OPLINE();
33626
5
        zend_throw_error(NULL,
33627
5
          "Cannot use \"parent\" when current class scope has no parent");
33628
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33629
5
        HANDLE_EXCEPTION();
33630
5
      }
33631
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
33632
0
      break;
33633
232
    case ZEND_FETCH_CLASS_STATIC:
33634
232
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
33635
171
        called_scope = Z_OBJCE(EX(This));
33636
171
      } else {
33637
61
        called_scope = Z_CE(EX(This));
33638
61
      }
33639
232
      ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
33640
232
      break;
33641
426
    EMPTY_SWITCH_DEFAULT_CASE()
33642
426
  }
33643
421
  ZEND_VM_NEXT_OPCODE();
33644
421
}
33645
33646
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33647
172
{
33648
172
  USE_OPLINE
33649
172
  zval *object;
33650
172
  zval *property;
33651
172
  zval *value;
33652
172
  zval *zptr;
33653
172
  void *_cache_slot[3] = {0};
33654
172
  void **cache_slot;
33655
172
  zend_property_info *prop_info;
33656
172
  zend_object *zobj;
33657
172
  zend_string *name, *tmp_name;
33658
33659
172
  SAVE_OPLINE();
33660
172
  object = &EX(This);
33661
172
  property = RT_CONSTANT(opline, opline->op2);
33662
33663
172
  do {
33664
172
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
33665
33666
172
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33667
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33668
0
        object = Z_REFVAL_P(object);
33669
0
        goto assign_op_object;
33670
0
      }
33671
0
      if (IS_UNUSED == IS_CV
33672
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33673
0
        ZVAL_UNDEFINED_OP1();
33674
0
      }
33675
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33676
0
      break;
33677
0
    }
33678
33679
172
assign_op_object:
33680
    /* here we are sure we are dealing with an object */
33681
172
    zobj = Z_OBJ_P(object);
33682
172
    if (IS_CONST == IS_CONST) {
33683
172
      name = Z_STR_P(property);
33684
172
    } else {
33685
0
      name = zval_try_get_tmp_string(property, &tmp_name);
33686
0
      if (UNEXPECTED(!name)) {
33687
0
        UNDEF_RESULT();
33688
0
        break;
33689
0
      }
33690
0
    }
33691
172
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
33692
172
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33693
134
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33694
27
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33695
0
          ZVAL_NULL(EX_VAR(opline->result.var));
33696
0
        }
33697
107
      } else {
33698
107
        zend_reference *ref;
33699
33700
107
        do {
33701
107
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
33702
3
            ref = Z_REF_P(zptr);
33703
3
            zptr = Z_REFVAL_P(zptr);
33704
3
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
33705
3
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
33706
3
              break;
33707
3
            }
33708
3
          }
33709
33710
104
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33711
104
          if (prop_info) {
33712
            /* special case for typed properties */
33713
34
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
33714
70
          } else {
33715
70
            zend_binary_op(zptr, zptr, value OPLINE_CC);
33716
70
          }
33717
104
        } while (0);
33718
33719
107
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33720
18
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
33721
18
        }
33722
107
      }
33723
134
    } else {
33724
38
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
33725
38
    }
33726
172
    if (IS_CONST != IS_CONST) {
33727
0
      zend_tmp_string_release(tmp_name);
33728
0
    }
33729
172
  } while (0);
33730
33731
172
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
33732
33733
33734
  /* assign_obj has two opcodes! */
33735
172
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
33736
172
}
33737
33738
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
33739
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33740
850
{
33741
850
  USE_OPLINE
33742
850
  zval *object;
33743
850
  zval *property;
33744
850
  zval *zptr;
33745
850
  void *_cache_slot[3] = {0};
33746
850
  void **cache_slot;
33747
850
  zend_property_info *prop_info;
33748
850
  zend_object *zobj;
33749
850
  zend_string *name, *tmp_name;
33750
33751
850
  SAVE_OPLINE();
33752
850
  object = &EX(This);
33753
850
  property = RT_CONSTANT(opline, opline->op2);
33754
33755
850
  do {
33756
850
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33757
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33758
0
        object = Z_REFVAL_P(object);
33759
0
        goto pre_incdec_object;
33760
0
      }
33761
0
      if (IS_UNUSED == IS_CV
33762
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33763
0
        ZVAL_UNDEFINED_OP1();
33764
0
      }
33765
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33766
0
      break;
33767
0
    }
33768
33769
850
pre_incdec_object:
33770
    /* here we are sure we are dealing with an object */
33771
850
    zobj = Z_OBJ_P(object);
33772
850
    if (IS_CONST == IS_CONST) {
33773
850
      name = Z_STR_P(property);
33774
850
    } else {
33775
0
      name = zval_try_get_tmp_string(property, &tmp_name);
33776
0
      if (UNEXPECTED(!name)) {
33777
0
        UNDEF_RESULT();
33778
0
        break;
33779
0
      }
33780
0
    }
33781
850
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
33782
850
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33783
792
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33784
7
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33785
7
          ZVAL_NULL(EX_VAR(opline->result.var));
33786
7
        }
33787
785
      } else {
33788
785
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
33789
785
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33790
785
      }
33791
792
    } else {
33792
58
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33793
58
    }
33794
850
    if (IS_CONST != IS_CONST) {
33795
0
      zend_tmp_string_release(tmp_name);
33796
0
    }
33797
850
  } while (0);
33798
33799
33800
850
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33801
850
}
33802
33803
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33804
20
{
33805
20
  USE_OPLINE
33806
20
  zval *object;
33807
20
  zval *property;
33808
20
  zval *zptr;
33809
20
  void *_cache_slot[3] = {0};
33810
20
  void **cache_slot;
33811
20
  zend_property_info *prop_info;
33812
20
  zend_object *zobj;
33813
20
  zend_string *name, *tmp_name;
33814
33815
20
  SAVE_OPLINE();
33816
20
  object = &EX(This);
33817
20
  property = RT_CONSTANT(opline, opline->op2);
33818
33819
20
  do {
33820
20
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33821
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33822
0
        object = Z_REFVAL_P(object);
33823
0
        goto post_incdec_object;
33824
0
      }
33825
0
      if (IS_UNUSED == IS_CV
33826
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33827
0
        ZVAL_UNDEFINED_OP1();
33828
0
      }
33829
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33830
0
      break;
33831
0
    }
33832
33833
20
post_incdec_object:
33834
    /* here we are sure we are dealing with an object */
33835
20
    zobj = Z_OBJ_P(object);
33836
20
    if (IS_CONST == IS_CONST) {
33837
20
      name = Z_STR_P(property);
33838
20
    } else {
33839
0
      name = zval_try_get_tmp_string(property, &tmp_name);
33840
0
      if (UNEXPECTED(!name)) {
33841
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33842
0
        break;
33843
0
      }
33844
0
    }
33845
20
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
33846
20
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33847
10
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33848
0
        ZVAL_NULL(EX_VAR(opline->result.var));
33849
10
      } else {
33850
10
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33851
10
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33852
10
      }
33853
10
    } else {
33854
10
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33855
10
    }
33856
20
    if (IS_CONST != IS_CONST) {
33857
0
      zend_tmp_string_release(tmp_name);
33858
0
    }
33859
20
  } while (0);
33860
33861
33862
20
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33863
20
}
33864
33865
static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33866
11.0k
{
33867
11.0k
  USE_OPLINE
33868
11.0k
  zval *container;
33869
11.0k
  void **cache_slot = NULL;
33870
33871
11.0k
  SAVE_OPLINE();
33872
11.0k
  container = &EX(This);
33873
33874
11.0k
  if (IS_UNUSED == IS_CONST ||
33875
11.0k
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33876
0
    do {
33877
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33878
0
        container = Z_REFVAL_P(container);
33879
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33880
0
          break;
33881
0
        }
33882
0
      }
33883
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33884
0
        ZVAL_UNDEFINED_OP1();
33885
0
      }
33886
0
      zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
33887
0
      ZVAL_NULL(EX_VAR(opline->result.var));
33888
0
      goto fetch_obj_r_finish;
33889
0
    } while (0);
33890
0
  }
33891
33892
  /* here we are sure we are dealing with an object */
33893
11.0k
  do {
33894
11.0k
    zend_object *zobj = Z_OBJ_P(container);
33895
11.0k
    zend_string *name, *tmp_name;
33896
11.0k
    zval *retval;
33897
33898
11.0k
    if (IS_CONST == IS_CONST) {
33899
11.0k
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
33900
33901
11.0k
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33902
9.23k
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33903
33904
9.23k
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33905
6.31k
fetch_obj_r_simple:
33906
6.31k
          retval = OBJ_PROP(zobj, prop_offset);
33907
6.31k
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
33908
6.25k
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33909
0
              goto fetch_obj_r_copy;
33910
6.25k
            } else {
33911
6.51k
fetch_obj_r_fast_copy:
33912
6.51k
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33913
6.51k
              ZEND_VM_NEXT_OPCODE();
33914
6.51k
            }
33915
6.25k
          }
33916
6.31k
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
33917
4.57k
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
33918
4.57k
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
33919
2.27k
            prop_offset = prop_info->offset;
33920
2.27k
            goto fetch_obj_r_simple;
33921
2.30k
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
33922
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
33923
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
33924
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
33925
33926
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
33927
0
            if (IS_UNUSED & IS_CV) {
33928
0
              GC_ADDREF(zobj);
33929
0
            }
33930
0
            if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
33931
0
              call_info |= ZEND_CALL_RELEASE_THIS;
33932
0
            }
33933
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
33934
0
            call->prev_execute_data = execute_data;
33935
0
            call->call = NULL;
33936
0
            call->return_value = EX_VAR(opline->result.var);
33937
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
33938
33939
0
            execute_data = call;
33940
0
            EG(current_execute_data) = execute_data;
33941
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
33942
33943
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
33944
            opline = hook->op_array.opcodes;
33945
#else
33946
0
            EX(opline) = hook->op_array.opcodes;
33947
0
#endif
33948
0
            LOAD_OPLINE_EX();
33949
33950
33951
0
            ZEND_VM_ENTER_EX();
33952
0
          }
33953
          /* Fall through to read_property for hooks. */
33954
4.57k
        } else if (EXPECTED(zobj->properties != NULL)) {
33955
345
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
33956
345
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33957
345
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33958
243
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33959
33960
243
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33961
243
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33962
33963
243
              if (EXPECTED(p->key == name) ||
33964
243
                  (EXPECTED(p->h == ZSTR_H(name)) &&
33965
0
                   EXPECTED(p->key != NULL) &&
33966
243
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
33967
243
                retval = &p->val;
33968
243
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33969
0
                  goto fetch_obj_r_copy;
33970
243
                } else {
33971
243
                  goto fetch_obj_r_fast_copy;
33972
243
                }
33973
243
              }
33974
243
            }
33975
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33976
0
          }
33977
102
          retval = zend_hash_find_known_hash(zobj->properties, name);
33978
102
          if (EXPECTED(retval)) {
33979
9
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
33980
9
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
33981
9
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33982
0
              goto fetch_obj_r_copy;
33983
9
            } else {
33984
9
              goto fetch_obj_r_fast_copy;
33985
9
            }
33986
9
          }
33987
102
        }
33988
9.23k
      }
33989
4.55k
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33990
4.55k
    } else {
33991
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33992
0
      if (UNEXPECTED(!name)) {
33993
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
33994
0
        break;
33995
0
      }
33996
0
    }
33997
33998
4.55k
#if ZEND_DEBUG
33999
    /* For non-standard object handlers, verify a declared property type in debug builds.
34000
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
34001
4.55k
    zend_property_info *prop_info = NULL;
34002
4.55k
    if (zobj->handlers->read_property != zend_std_read_property) {
34003
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
34004
0
    }
34005
4.55k
#endif
34006
4.55k
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
34007
4.55k
#if ZEND_DEBUG
34008
4.55k
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
34009
4.55k
        && ZEND_TYPE_IS_SET(prop_info->type)) {
34010
0
      ZVAL_OPT_DEREF(retval);
34011
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
34012
0
    }
34013
4.55k
#endif
34014
34015
4.55k
    if (IS_CONST != IS_CONST) {
34016
0
      zend_tmp_string_release(tmp_name);
34017
0
    }
34018
34019
4.55k
    if (retval != EX_VAR(opline->result.var)) {
34020
2.17k
fetch_obj_r_copy:
34021
2.17k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34022
2.38k
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
34023
0
      zend_unwrap_reference(retval);
34024
0
    }
34025
4.55k
  } while (0);
34026
34027
4.55k
fetch_obj_r_finish:
34028
34029
34030
2.24k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34031
2.24k
}
34032
34033
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34034
11.0k
{
34035
11.0k
  ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34036
11.0k
}
34037
34038
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34039
2.86k
{
34040
2.86k
  USE_OPLINE
34041
2.86k
  zval *property, *container, *result;
34042
34043
2.86k
  SAVE_OPLINE();
34044
34045
2.86k
  container = &EX(This);
34046
2.86k
  property = RT_CONSTANT(opline, opline->op2);
34047
2.86k
  result = EX_VAR(opline->result.var);
34048
2.86k
  zend_fetch_property_address(
34049
2.86k
    result, container, IS_UNUSED, property, IS_CONST,
34050
2.86k
    ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
34051
2.86k
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
34052
34053
2.86k
  if (IS_UNUSED == IS_VAR) {
34054
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
34055
0
  }
34056
2.86k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34057
2.86k
}
34058
34059
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34060
0
{
34061
0
  USE_OPLINE
34062
0
  zval *property, *container, *result;
34063
34064
0
  SAVE_OPLINE();
34065
0
  container = &EX(This);
34066
0
  property = RT_CONSTANT(opline, opline->op2);
34067
0
  result = EX_VAR(opline->result.var);
34068
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);
34069
34070
0
  if (IS_UNUSED == IS_VAR) {
34071
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
34072
0
  }
34073
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34074
0
}
34075
34076
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34077
353
{
34078
353
  USE_OPLINE
34079
353
  zval *container;
34080
353
  void **cache_slot = NULL;
34081
34082
353
  SAVE_OPLINE();
34083
353
  container = &EX(This);
34084
34085
353
  if (IS_UNUSED == IS_CONST ||
34086
353
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
34087
0
    do {
34088
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
34089
0
        container = Z_REFVAL_P(container);
34090
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
34091
0
          break;
34092
0
        }
34093
0
      }
34094
0
      if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
34095
0
        ZVAL_UNDEFINED_OP2();
34096
0
      }
34097
0
      ZVAL_NULL(EX_VAR(opline->result.var));
34098
0
      goto fetch_obj_is_finish;
34099
0
    } while (0);
34100
0
  }
34101
34102
  /* here we are sure we are dealing with an object */
34103
353
  do {
34104
353
    zend_object *zobj = Z_OBJ_P(container);
34105
353
    zend_string *name, *tmp_name;
34106
353
    zval *retval;
34107
34108
353
    if (IS_CONST == IS_CONST) {
34109
353
      cache_slot = CACHE_ADDR(opline->extended_value);
34110
34111
353
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
34112
219
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34113
34114
219
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34115
171
fetch_obj_is_simple:
34116
171
          retval = OBJ_PROP(zobj, prop_offset);
34117
171
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
34118
171
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34119
0
              goto fetch_obj_is_copy;
34120
171
            } else {
34121
171
fetch_obj_is_fast_copy:
34122
171
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34123
171
              ZEND_VM_NEXT_OPCODE();
34124
171
            }
34125
171
          }
34126
171
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
34127
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
34128
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
34129
0
            prop_offset = prop_info->offset;
34130
0
            goto fetch_obj_is_simple;
34131
0
          }
34132
          /* Fall through to read_property for hooks. */
34133
48
        } else if (EXPECTED(zobj->properties != NULL)) {
34134
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
34135
0
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34136
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
34137
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
34138
34139
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
34140
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
34141
34142
0
              if (EXPECTED(p->key == name) ||
34143
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
34144
0
                   EXPECTED(p->key != NULL) &&
34145
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
34146
0
                retval = &p->val;
34147
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34148
0
                  goto fetch_obj_is_copy;
34149
0
                } else {
34150
0
                  goto fetch_obj_is_fast_copy;
34151
0
                }
34152
0
              }
34153
0
            }
34154
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
34155
0
          }
34156
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
34157
0
          if (EXPECTED(retval)) {
34158
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
34159
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
34160
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34161
0
              goto fetch_obj_is_copy;
34162
0
            } else {
34163
0
              goto fetch_obj_is_fast_copy;
34164
0
            }
34165
0
          }
34166
0
        }
34167
219
      }
34168
182
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34169
182
    } else {
34170
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34171
0
      if (UNEXPECTED(!name)) {
34172
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
34173
0
        break;
34174
0
      }
34175
0
    }
34176
34177
182
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
34178
34179
182
    if (IS_CONST != IS_CONST) {
34180
0
      zend_tmp_string_release(tmp_name);
34181
0
    }
34182
34183
182
    if (retval != EX_VAR(opline->result.var)) {
34184
173
fetch_obj_is_copy:
34185
173
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34186
173
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
34187
9
      zend_unwrap_reference(retval);
34188
9
    }
34189
182
  } while (0);
34190
34191
182
fetch_obj_is_finish:
34192
34193
34194
182
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34195
182
}
34196
34197
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34198
70
{
34199
#if 0
34200
  USE_OPLINE
34201
#endif
34202
34203
70
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
34204
    /* Behave like FETCH_OBJ_W */
34205
15
    if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
34206
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34207
0
    }
34208
15
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34209
55
  } else {
34210
55
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34211
55
  }
34212
70
}
34213
34214
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34215
46
{
34216
46
  USE_OPLINE
34217
46
  zval *container, *property, *result;
34218
34219
46
  SAVE_OPLINE();
34220
46
  container = &EX(This);
34221
46
  property = RT_CONSTANT(opline, opline->op2);
34222
46
  result = EX_VAR(opline->result.var);
34223
46
  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);
34224
34225
46
  if (IS_UNUSED == IS_VAR) {
34226
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
34227
0
  }
34228
46
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34229
46
}
34230
34231
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34232
3.19k
{
34233
3.19k
  USE_OPLINE
34234
3.19k
  zval *object, *value, tmp;
34235
3.19k
  zend_object *zobj;
34236
3.19k
  zend_string *name, *tmp_name;
34237
3.19k
  zend_refcounted *garbage = NULL;
34238
34239
3.19k
  SAVE_OPLINE();
34240
3.19k
  object = &EX(This);
34241
3.19k
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
34242
34243
3.19k
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34244
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34245
0
      object = Z_REFVAL_P(object);
34246
0
      goto assign_object;
34247
0
    }
34248
0
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34249
0
    value = &EG(uninitialized_zval);
34250
0
    goto free_and_exit_assign_obj;
34251
0
  }
34252
34253
3.19k
assign_object:
34254
3.19k
  zobj = Z_OBJ_P(object);
34255
3.19k
  if (IS_CONST == IS_CONST) {
34256
3.19k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34257
1.99k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
34258
1.99k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34259
1.99k
      zval *property_val;
34260
1.99k
      zend_property_info *prop_info;
34261
34262
1.99k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34263
1.78k
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34264
34265
1.78k
assign_obj_simple:
34266
1.78k
        property_val = OBJ_PROP(zobj, prop_offset);
34267
1.78k
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
34268
856
          if (prop_info != NULL) {
34269
126
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34270
126
            goto free_and_exit_assign_obj;
34271
730
          } else {
34272
733
fast_assign_obj:
34273
733
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
34274
733
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34275
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
34276
0
            }
34277
733
            goto exit_assign_obj;
34278
730
          }
34279
856
        }
34280
1.78k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34281
169
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34282
169
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34283
0
          zobj = zend_lazy_object_init(zobj);
34284
0
          if (!zobj) {
34285
0
            value = &EG(uninitialized_zval);
34286
0
            goto free_and_exit_assign_obj;
34287
0
          }
34288
0
        }
34289
169
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34290
133
          rebuild_object_properties_internal(zobj);
34291
133
        }
34292
169
        if (EXPECTED(zobj->properties != NULL)) {
34293
136
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34294
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34295
0
              GC_DELREF(zobj->properties);
34296
0
            }
34297
0
            zobj->properties = zend_array_dup(zobj->properties);
34298
0
          }
34299
136
          property_val = zend_hash_find_known_hash(zobj->properties, name);
34300
136
          if (property_val) {
34301
3
            goto fast_assign_obj;
34302
3
          }
34303
136
        }
34304
34305
166
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34306
133
          if (IS_CONST == IS_CONST) {
34307
133
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34308
0
              Z_ADDREF_P(value);
34309
0
            }
34310
133
          } else if (IS_CONST != IS_TMP_VAR) {
34311
0
            if (Z_ISREF_P(value)) {
34312
0
              if (IS_CONST == IS_VAR) {
34313
0
                zend_reference *ref = Z_REF_P(value);
34314
0
                if (GC_DELREF(ref) == 0) {
34315
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34316
0
                  efree_size(ref, sizeof(zend_reference));
34317
0
                  value = &tmp;
34318
0
                } else {
34319
0
                  value = Z_REFVAL_P(value);
34320
0
                  Z_TRY_ADDREF_P(value);
34321
0
                }
34322
0
              } else {
34323
0
                value = Z_REFVAL_P(value);
34324
0
                Z_TRY_ADDREF_P(value);
34325
0
              }
34326
0
            } else if (IS_CONST == IS_CV) {
34327
0
              Z_TRY_ADDREF_P(value);
34328
0
            }
34329
0
          }
34330
133
          zend_hash_add_new(zobj->properties, name, value);
34331
133
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34332
3
            ZVAL_COPY(EX_VAR(opline->result.var), value);
34333
3
          }
34334
133
          goto exit_assign_obj;
34335
133
        }
34336
166
      } else {
34337
43
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34338
43
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34339
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
34340
0
          prop_offset = prop_info->offset;
34341
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34342
0
            prop_info = NULL;
34343
0
          }
34344
0
          goto assign_obj_simple;
34345
0
        }
34346
        /* Fall through to write_property for hooks. */
34347
43
      }
34348
1.99k
    }
34349
2.20k
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34350
2.20k
  } else {
34351
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34352
0
    if (UNEXPECTED(!name)) {
34353
34354
0
      UNDEF_RESULT();
34355
0
      goto exit_assign_obj;
34356
0
    }
34357
0
  }
34358
34359
2.20k
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
34360
0
    ZVAL_DEREF(value);
34361
0
  }
34362
34363
2.20k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34364
34365
2.20k
  if (IS_CONST != IS_CONST) {
34366
0
    zend_tmp_string_release(tmp_name);
34367
0
  }
34368
34369
2.33k
free_and_exit_assign_obj:
34370
2.33k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34371
13
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34372
13
  }
34373
34374
3.19k
exit_assign_obj:
34375
3.19k
  if (garbage) {
34376
141
    GC_DTOR_NO_REF(garbage);
34377
141
  }
34378
34379
34380
  /* assign_obj has two opcodes! */
34381
3.19k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34382
3.19k
}
34383
34384
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34385
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34386
4.28k
{
34387
4.28k
  USE_OPLINE
34388
4.28k
  zval *object, *value, tmp;
34389
4.28k
  zend_object *zobj;
34390
4.28k
  zend_string *name, *tmp_name;
34391
4.28k
  zend_refcounted *garbage = NULL;
34392
34393
4.28k
  SAVE_OPLINE();
34394
4.28k
  object = &EX(This);
34395
4.28k
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
34396
34397
4.28k
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34398
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34399
0
      object = Z_REFVAL_P(object);
34400
0
      goto assign_object;
34401
0
    }
34402
0
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34403
0
    value = &EG(uninitialized_zval);
34404
0
    goto free_and_exit_assign_obj;
34405
0
  }
34406
34407
4.28k
assign_object:
34408
4.28k
  zobj = Z_OBJ_P(object);
34409
4.28k
  if (IS_CONST == IS_CONST) {
34410
4.28k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34411
3.97k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
34412
3.97k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34413
3.97k
      zval *property_val;
34414
3.97k
      zend_property_info *prop_info;
34415
34416
3.97k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34417
3.46k
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34418
34419
3.48k
assign_obj_simple:
34420
3.48k
        property_val = OBJ_PROP(zobj, prop_offset);
34421
3.48k
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
34422
2.90k
          if (prop_info != NULL) {
34423
26
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34424
26
            goto free_and_exit_assign_obj;
34425
2.88k
          } else {
34426
3.01k
fast_assign_obj:
34427
3.01k
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
34428
3.01k
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34429
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
34430
0
            }
34431
3.01k
            goto exit_assign_obj;
34432
2.88k
          }
34433
2.90k
        }
34434
3.48k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34435
492
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34436
492
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34437
0
          zobj = zend_lazy_object_init(zobj);
34438
0
          if (!zobj) {
34439
0
            value = &EG(uninitialized_zval);
34440
0
            goto free_and_exit_assign_obj;
34441
0
          }
34442
0
        }
34443
492
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34444
0
          rebuild_object_properties_internal(zobj);
34445
0
        }
34446
492
        if (EXPECTED(zobj->properties != NULL)) {
34447
138
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34448
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34449
0
              GC_DELREF(zobj->properties);
34450
0
            }
34451
0
            zobj->properties = zend_array_dup(zobj->properties);
34452
0
          }
34453
138
          property_val = zend_hash_find_known_hash(zobj->properties, name);
34454
138
          if (property_val) {
34455
138
            goto fast_assign_obj;
34456
138
          }
34457
138
        }
34458
34459
354
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34460
0
          if (IS_TMP_VAR == IS_CONST) {
34461
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34462
0
              Z_ADDREF_P(value);
34463
0
            }
34464
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
34465
0
            if (Z_ISREF_P(value)) {
34466
0
              if (IS_TMP_VAR == IS_VAR) {
34467
0
                zend_reference *ref = Z_REF_P(value);
34468
0
                if (GC_DELREF(ref) == 0) {
34469
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34470
0
                  efree_size(ref, sizeof(zend_reference));
34471
0
                  value = &tmp;
34472
0
                } else {
34473
0
                  value = Z_REFVAL_P(value);
34474
0
                  Z_TRY_ADDREF_P(value);
34475
0
                }
34476
0
              } else {
34477
0
                value = Z_REFVAL_P(value);
34478
0
                Z_TRY_ADDREF_P(value);
34479
0
              }
34480
0
            } else if (IS_TMP_VAR == IS_CV) {
34481
0
              Z_TRY_ADDREF_P(value);
34482
0
            }
34483
0
          }
34484
0
          zend_hash_add_new(zobj->properties, name, value);
34485
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34486
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
34487
0
          }
34488
0
          goto exit_assign_obj;
34489
0
        }
34490
354
      } else {
34491
15
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34492
15
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34493
15
          prop_info = CACHED_PTR_EX(cache_slot + 2);
34494
15
          prop_offset = prop_info->offset;
34495
15
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34496
10
            prop_info = NULL;
34497
10
          }
34498
15
          goto assign_obj_simple;
34499
15
        }
34500
        /* Fall through to write_property for hooks. */
34501
15
      }
34502
3.97k
    }
34503
1.23k
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34504
1.23k
  } else {
34505
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34506
0
    if (UNEXPECTED(!name)) {
34507
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34508
0
      UNDEF_RESULT();
34509
0
      goto exit_assign_obj;
34510
0
    }
34511
0
  }
34512
34513
1.23k
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
34514
0
    ZVAL_DEREF(value);
34515
0
  }
34516
34517
1.23k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34518
34519
1.23k
  if (IS_CONST != IS_CONST) {
34520
0
    zend_tmp_string_release(tmp_name);
34521
0
  }
34522
34523
1.26k
free_and_exit_assign_obj:
34524
1.26k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34525
2
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34526
2
  }
34527
1.26k
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34528
4.28k
exit_assign_obj:
34529
4.28k
  if (garbage) {
34530
173
    GC_DTOR_NO_REF(garbage);
34531
173
  }
34532
34533
34534
  /* assign_obj has two opcodes! */
34535
4.28k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34536
4.28k
}
34537
34538
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34539
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34540
1.30k
{
34541
1.30k
  USE_OPLINE
34542
1.30k
  zval *object, *value, tmp;
34543
1.30k
  zend_object *zobj;
34544
1.30k
  zend_string *name, *tmp_name;
34545
1.30k
  zend_refcounted *garbage = NULL;
34546
34547
1.30k
  SAVE_OPLINE();
34548
1.30k
  object = &EX(This);
34549
1.30k
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
34550
34551
1.30k
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34552
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34553
0
      object = Z_REFVAL_P(object);
34554
0
      goto assign_object;
34555
0
    }
34556
0
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34557
0
    value = &EG(uninitialized_zval);
34558
0
    goto free_and_exit_assign_obj;
34559
0
  }
34560
34561
1.30k
assign_object:
34562
1.30k
  zobj = Z_OBJ_P(object);
34563
1.30k
  if (IS_CONST == IS_CONST) {
34564
1.30k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34565
955
      void **cache_slot = CACHE_ADDR(opline->extended_value);
34566
955
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34567
955
      zval *property_val;
34568
955
      zend_property_info *prop_info;
34569
34570
955
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34571
887
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34572
34573
902
assign_obj_simple:
34574
902
        property_val = OBJ_PROP(zobj, prop_offset);
34575
902
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
34576
698
          if (prop_info != NULL) {
34577
643
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34578
643
            goto free_and_exit_assign_obj;
34579
643
          } else {
34580
65
fast_assign_obj:
34581
65
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
34582
65
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34583
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
34584
0
            }
34585
65
            goto exit_assign_obj;
34586
55
          }
34587
698
        }
34588
902
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34589
53
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34590
53
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34591
0
          zobj = zend_lazy_object_init(zobj);
34592
0
          if (!zobj) {
34593
0
            value = &EG(uninitialized_zval);
34594
0
            goto free_and_exit_assign_obj;
34595
0
          }
34596
0
        }
34597
53
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34598
23
          rebuild_object_properties_internal(zobj);
34599
23
        }
34600
53
        if (EXPECTED(zobj->properties != NULL)) {
34601
45
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34602
14
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34603
14
              GC_DELREF(zobj->properties);
34604
14
            }
34605
14
            zobj->properties = zend_array_dup(zobj->properties);
34606
14
          }
34607
45
          property_val = zend_hash_find_known_hash(zobj->properties, name);
34608
45
          if (property_val) {
34609
10
            goto fast_assign_obj;
34610
10
          }
34611
45
        }
34612
34613
43
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34614
23
          if (IS_VAR == IS_CONST) {
34615
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34616
0
              Z_ADDREF_P(value);
34617
0
            }
34618
23
          } else if (IS_VAR != IS_TMP_VAR) {
34619
23
            if (Z_ISREF_P(value)) {
34620
0
              if (IS_VAR == IS_VAR) {
34621
0
                zend_reference *ref = Z_REF_P(value);
34622
0
                if (GC_DELREF(ref) == 0) {
34623
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34624
0
                  efree_size(ref, sizeof(zend_reference));
34625
0
                  value = &tmp;
34626
0
                } else {
34627
0
                  value = Z_REFVAL_P(value);
34628
0
                  Z_TRY_ADDREF_P(value);
34629
0
                }
34630
0
              } else {
34631
0
                value = Z_REFVAL_P(value);
34632
0
                Z_TRY_ADDREF_P(value);
34633
0
              }
34634
23
            } else if (IS_VAR == IS_CV) {
34635
0
              Z_TRY_ADDREF_P(value);
34636
0
            }
34637
23
          }
34638
23
          zend_hash_add_new(zobj->properties, name, value);
34639
23
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34640
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
34641
0
          }
34642
23
          goto exit_assign_obj;
34643
23
        }
34644
43
      } else {
34645
15
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34646
15
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34647
15
          prop_info = CACHED_PTR_EX(cache_slot + 2);
34648
15
          prop_offset = prop_info->offset;
34649
15
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34650
0
            prop_info = NULL;
34651
0
          }
34652
15
          goto assign_obj_simple;
34653
15
        }
34654
        /* Fall through to write_property for hooks. */
34655
15
      }
34656
955
    }
34657
569
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34658
569
  } else {
34659
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34660
0
    if (UNEXPECTED(!name)) {
34661
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34662
0
      UNDEF_RESULT();
34663
0
      goto exit_assign_obj;
34664
0
    }
34665
0
  }
34666
34667
569
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
34668
569
    ZVAL_DEREF(value);
34669
569
  }
34670
34671
569
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34672
34673
569
  if (IS_CONST != IS_CONST) {
34674
0
    zend_tmp_string_release(tmp_name);
34675
0
  }
34676
34677
1.21k
free_and_exit_assign_obj:
34678
1.21k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34679
25
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34680
25
  }
34681
1.21k
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34682
1.30k
exit_assign_obj:
34683
1.30k
  if (garbage) {
34684
638
    GC_DTOR_NO_REF(garbage);
34685
638
  }
34686
34687
34688
  /* assign_obj has two opcodes! */
34689
1.30k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34690
1.30k
}
34691
34692
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34693
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34694
5.74k
{
34695
5.74k
  USE_OPLINE
34696
5.74k
  zval *object, *value, tmp;
34697
5.74k
  zend_object *zobj;
34698
5.74k
  zend_string *name, *tmp_name;
34699
5.74k
  zend_refcounted *garbage = NULL;
34700
34701
5.74k
  SAVE_OPLINE();
34702
5.74k
  object = &EX(This);
34703
5.74k
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
34704
34705
5.74k
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34706
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34707
0
      object = Z_REFVAL_P(object);
34708
0
      goto assign_object;
34709
0
    }
34710
0
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34711
0
    value = &EG(uninitialized_zval);
34712
0
    goto free_and_exit_assign_obj;
34713
0
  }
34714
34715
5.74k
assign_object:
34716
5.74k
  zobj = Z_OBJ_P(object);
34717
5.74k
  if (IS_CONST == IS_CONST) {
34718
5.74k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34719
4.21k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
34720
4.21k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34721
4.21k
      zval *property_val;
34722
4.21k
      zend_property_info *prop_info;
34723
34724
4.21k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34725
2.16k
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34726
34727
2.35k
assign_obj_simple:
34728
2.35k
        property_val = OBJ_PROP(zobj, prop_offset);
34729
2.35k
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
34730
1.33k
          if (prop_info != NULL) {
34731
358
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34732
358
            goto free_and_exit_assign_obj;
34733
980
          } else {
34734
1.06k
fast_assign_obj:
34735
1.06k
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
34736
1.06k
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34737
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
34738
0
            }
34739
1.06k
            goto exit_assign_obj;
34740
980
          }
34741
1.33k
        }
34742
2.35k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34743
287
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34744
287
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34745
0
          zobj = zend_lazy_object_init(zobj);
34746
0
          if (!zobj) {
34747
0
            value = &EG(uninitialized_zval);
34748
0
            goto free_and_exit_assign_obj;
34749
0
          }
34750
0
        }
34751
287
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34752
5
          rebuild_object_properties_internal(zobj);
34753
5
        }
34754
287
        if (EXPECTED(zobj->properties != NULL)) {
34755
85
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34756
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34757
0
              GC_DELREF(zobj->properties);
34758
0
            }
34759
0
            zobj->properties = zend_array_dup(zobj->properties);
34760
0
          }
34761
85
          property_val = zend_hash_find_known_hash(zobj->properties, name);
34762
85
          if (property_val) {
34763
80
            goto fast_assign_obj;
34764
80
          }
34765
85
        }
34766
34767
207
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34768
5
          if (IS_CV == IS_CONST) {
34769
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34770
0
              Z_ADDREF_P(value);
34771
0
            }
34772
5
          } else if (IS_CV != IS_TMP_VAR) {
34773
5
            if (Z_ISREF_P(value)) {
34774
0
              if (IS_CV == IS_VAR) {
34775
0
                zend_reference *ref = Z_REF_P(value);
34776
0
                if (GC_DELREF(ref) == 0) {
34777
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34778
0
                  efree_size(ref, sizeof(zend_reference));
34779
0
                  value = &tmp;
34780
0
                } else {
34781
0
                  value = Z_REFVAL_P(value);
34782
0
                  Z_TRY_ADDREF_P(value);
34783
0
                }
34784
0
              } else {
34785
0
                value = Z_REFVAL_P(value);
34786
0
                Z_TRY_ADDREF_P(value);
34787
0
              }
34788
5
            } else if (IS_CV == IS_CV) {
34789
5
              Z_TRY_ADDREF_P(value);
34790
5
            }
34791
5
          }
34792
5
          zend_hash_add_new(zobj->properties, name, value);
34793
5
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34794
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
34795
0
          }
34796
5
          goto exit_assign_obj;
34797
5
        }
34798
1.75k
      } else {
34799
1.75k
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34800
1.75k
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34801
181
          prop_info = CACHED_PTR_EX(cache_slot + 2);
34802
181
          prop_offset = prop_info->offset;
34803
181
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34804
161
            prop_info = NULL;
34805
161
          }
34806
181
          goto assign_obj_simple;
34807
181
        }
34808
        /* Fall through to write_property for hooks. */
34809
1.75k
      }
34810
4.21k
    }
34811
4.32k
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34812
4.32k
  } else {
34813
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34814
0
    if (UNEXPECTED(!name)) {
34815
34816
0
      UNDEF_RESULT();
34817
0
      goto exit_assign_obj;
34818
0
    }
34819
0
  }
34820
34821
4.32k
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
34822
4.32k
    ZVAL_DEREF(value);
34823
4.32k
  }
34824
34825
4.32k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34826
34827
4.32k
  if (IS_CONST != IS_CONST) {
34828
0
    zend_tmp_string_release(tmp_name);
34829
0
  }
34830
34831
4.32k
free_and_exit_assign_obj:
34832
3.10k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34833
7
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34834
7
  }
34835
34836
4.16k
exit_assign_obj:
34837
4.16k
  if (garbage) {
34838
328
    GC_DTOR_NO_REF(garbage);
34839
328
  }
34840
34841
34842
  /* assign_obj has two opcodes! */
34843
4.16k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34844
4.16k
}
34845
34846
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34847
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34848
7
{
34849
7
  USE_OPLINE
34850
7
  zval *property, *container, *value_ptr;
34851
34852
7
  SAVE_OPLINE();
34853
34854
7
  container = &EX(This);
34855
7
  property = RT_CONSTANT(opline, opline->op2);
34856
34857
7
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
34858
34859
7
  if (1) {
34860
7
    if (IS_UNUSED == IS_UNUSED) {
34861
7
      if (IS_CONST == IS_CONST) {
34862
7
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34863
7
      } else {
34864
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34865
0
      }
34866
7
    } else {
34867
0
      if (IS_CONST == IS_CONST) {
34868
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34869
0
      } else {
34870
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34871
0
      }
34872
0
    }
34873
7
  } else {
34874
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34875
0
  }
34876
34877
34878
7
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34879
7
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34880
7
}
34881
34882
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34883
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34884
76
{
34885
76
  USE_OPLINE
34886
76
  zval *property, *container, *value_ptr;
34887
34888
76
  SAVE_OPLINE();
34889
34890
76
  container = &EX(This);
34891
76
  property = RT_CONSTANT(opline, opline->op2);
34892
34893
76
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
34894
34895
76
  if (1) {
34896
76
    if (IS_UNUSED == IS_UNUSED) {
34897
76
      if (IS_CONST == IS_CONST) {
34898
76
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34899
76
      } else {
34900
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34901
0
      }
34902
76
    } else {
34903
0
      if (IS_CONST == IS_CONST) {
34904
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34905
0
      } else {
34906
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34907
0
      }
34908
0
    }
34909
76
  } else {
34910
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34911
0
  }
34912
34913
34914
34915
76
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
34916
76
}
34917
34918
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34919
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34920
289k
{
34921
289k
  USE_OPLINE
34922
289k
  zend_string **rope;
34923
289k
  zval *var;
34924
34925
  /* Compiler allocates the necessary number of zval slots to keep the rope */
34926
289k
  rope = (zend_string**)EX_VAR(opline->result.var);
34927
289k
  if (IS_CONST == IS_CONST) {
34928
289k
    var = RT_CONSTANT(opline, opline->op2);
34929
289k
    rope[0] = Z_STR_P(var);
34930
289k
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
34931
3
      Z_ADDREF_P(var);
34932
3
    }
34933
289k
  } else {
34934
0
    var = RT_CONSTANT(opline, opline->op2);
34935
0
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
34936
0
      if (IS_CONST == IS_CV) {
34937
0
        rope[0] = zend_string_copy(Z_STR_P(var));
34938
0
      } else {
34939
0
        rope[0] = Z_STR_P(var);
34940
0
      }
34941
0
    } else {
34942
0
      SAVE_OPLINE();
34943
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
34944
0
        ZVAL_UNDEFINED_OP2();
34945
0
      }
34946
0
      rope[0] = zval_get_string_func(var);
34947
34948
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34949
0
    }
34950
0
  }
34951
289k
  ZEND_VM_NEXT_OPCODE();
34952
289k
}
34953
34954
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34955
0
{
34956
0
  zval *class_name;
34957
0
  USE_OPLINE
34958
34959
0
  SAVE_OPLINE();
34960
0
  if (IS_CONST == IS_UNUSED) {
34961
0
    Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
34962
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34963
0
  } else if (IS_CONST == IS_CONST) {
34964
0
    zend_class_entry *ce = CACHED_PTR(opline->extended_value);
34965
34966
0
    if (UNEXPECTED(ce == NULL)) {
34967
0
      class_name = RT_CONSTANT(opline, opline->op2);
34968
0
      ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
34969
0
      CACHE_PTR(opline->extended_value, ce);
34970
0
    }
34971
0
    Z_CE_P(EX_VAR(opline->result.var)) = ce;
34972
0
  } else {
34973
0
    class_name = RT_CONSTANT(opline, opline->op2);
34974
0
try_class_name:
34975
0
    if (Z_TYPE_P(class_name) == IS_OBJECT) {
34976
0
      Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
34977
0
    } else if (Z_TYPE_P(class_name) == IS_STRING) {
34978
0
      Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
34979
0
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
34980
0
      class_name = Z_REFVAL_P(class_name);
34981
0
      goto try_class_name;
34982
0
    } else {
34983
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
34984
0
        ZVAL_UNDEFINED_OP2();
34985
0
        if (UNEXPECTED(EG(exception) != NULL)) {
34986
0
          HANDLE_EXCEPTION();
34987
0
        }
34988
0
      }
34989
0
      zend_throw_error(NULL, "Class name must be a valid object or a string");
34990
0
    }
34991
0
  }
34992
34993
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34994
0
}
34995
34996
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34997
5.23k
{
34998
5.23k
  USE_OPLINE
34999
5.23k
  zval *function_name;
35000
5.23k
  zval *object;
35001
5.23k
  zend_function *fbc;
35002
5.23k
  zend_class_entry *called_scope;
35003
5.23k
  zend_object *obj;
35004
5.23k
  zend_execute_data *call;
35005
5.23k
  uint32_t call_info;
35006
35007
5.23k
  SAVE_OPLINE();
35008
35009
5.23k
  object = &EX(This);
35010
35011
5.23k
  if (IS_CONST != IS_CONST) {
35012
0
    function_name = RT_CONSTANT(opline, opline->op2);
35013
0
  }
35014
35015
5.23k
  if (IS_CONST != IS_CONST &&
35016
5.23k
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
35017
0
    do {
35018
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
35019
0
        function_name = Z_REFVAL_P(function_name);
35020
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
35021
0
          break;
35022
0
        }
35023
0
      } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
35024
0
        ZVAL_UNDEFINED_OP2();
35025
0
        if (UNEXPECTED(EG(exception) != NULL)) {
35026
35027
0
          HANDLE_EXCEPTION();
35028
0
        }
35029
0
      }
35030
0
      zend_throw_error(NULL, "Method name must be a string");
35031
35032
35033
0
      HANDLE_EXCEPTION();
35034
0
    } while (0);
35035
0
  }
35036
35037
5.23k
  if (IS_UNUSED == IS_UNUSED) {
35038
5.23k
    obj = Z_OBJ_P(object);
35039
5.23k
  } else {
35040
0
    do {
35041
0
      if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
35042
0
        obj = Z_OBJ_P(object);
35043
0
      } else {
35044
0
        if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
35045
0
          zend_reference *ref = Z_REF_P(object);
35046
35047
0
          object = &ref->val;
35048
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
35049
0
            obj = Z_OBJ_P(object);
35050
0
            if (IS_UNUSED & IS_VAR) {
35051
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
35052
0
                efree_size(ref, sizeof(zend_reference));
35053
0
              } else {
35054
0
                Z_ADDREF_P(object);
35055
0
              }
35056
0
            }
35057
0
            break;
35058
0
          }
35059
0
        }
35060
0
        if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35061
0
          object = ZVAL_UNDEFINED_OP1();
35062
0
          if (UNEXPECTED(EG(exception) != NULL)) {
35063
0
            if (IS_CONST != IS_CONST) {
35064
35065
0
            }
35066
0
            HANDLE_EXCEPTION();
35067
0
          }
35068
0
        }
35069
0
        if (IS_CONST == IS_CONST) {
35070
0
          function_name = RT_CONSTANT(opline, opline->op2);
35071
0
        }
35072
0
        zend_invalid_method_call(object, function_name);
35073
35074
35075
0
        HANDLE_EXCEPTION();
35076
0
      }
35077
0
    } while (0);
35078
0
  }
35079
35080
5.23k
  called_scope = obj->ce;
35081
35082
5.23k
  if (IS_CONST == IS_CONST &&
35083
5.23k
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
35084
4.67k
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
35085
4.67k
  } else {
35086
563
    zend_object *orig_obj = obj;
35087
35088
563
    if (IS_CONST == IS_CONST) {
35089
563
      function_name = RT_CONSTANT(opline, opline->op2);
35090
563
    }
35091
35092
    /* First, locate the function. */
35093
563
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
35094
563
    if (UNEXPECTED(fbc == NULL)) {
35095
32
      if (EXPECTED(!EG(exception))) {
35096
27
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
35097
27
      }
35098
35099
32
      if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
35100
0
        zend_objects_store_del(orig_obj);
35101
0
      }
35102
32
      HANDLE_EXCEPTION();
35103
32
    }
35104
531
    if (IS_CONST == IS_CONST &&
35105
531
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
35106
531
        EXPECTED(obj == orig_obj)) {
35107
497
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
35108
497
    }
35109
531
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
35110
0
      GC_ADDREF(obj); /* For $this pointer */
35111
0
      if (GC_DELREF(orig_obj) == 0) {
35112
0
        zend_objects_store_del(orig_obj);
35113
0
      }
35114
0
    }
35115
531
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35116
337
      init_func_run_time_cache(&fbc->op_array);
35117
337
    }
35118
531
  }
35119
35120
5.20k
  if (IS_CONST != IS_CONST) {
35121
35122
0
  }
35123
35124
5.20k
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35125
5.20k
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
35126
5
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
35127
0
      zend_objects_store_del(obj);
35128
0
      if (UNEXPECTED(EG(exception))) {
35129
0
        HANDLE_EXCEPTION();
35130
0
      }
35131
0
    }
35132
    /* call static method */
35133
5
    obj = (zend_object*)called_scope;
35134
5
    call_info = ZEND_CALL_NESTED_FUNCTION;
35135
5.20k
  } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
35136
0
    if (IS_UNUSED == IS_CV) {
35137
0
      GC_ADDREF(obj); /* For $this pointer */
35138
0
    }
35139
    /* CV may be changed indirectly (e.g. when it's a reference) */
35140
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
35141
0
  }
35142
35143
5.20k
  call = zend_vm_stack_push_call_frame(call_info,
35144
5.20k
    fbc, opline->extended_value, obj);
35145
5.20k
  call->prev_execute_data = EX(call);
35146
5.20k
  EX(call) = call;
35147
35148
5.20k
  ZEND_VM_NEXT_OPCODE();
35149
5.20k
}
35150
35151
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35152
996
{
35153
996
  USE_OPLINE
35154
996
  zval *function_name;
35155
996
  zend_class_entry *ce;
35156
996
  uint32_t call_info;
35157
996
  zend_function *fbc;
35158
996
  zend_execute_data *call;
35159
35160
996
  SAVE_OPLINE();
35161
35162
996
  if (IS_UNUSED == IS_CONST) {
35163
    /* no function found. try a static method in class */
35164
0
    ce = CACHED_PTR(opline->result.num);
35165
0
    if (UNEXPECTED(ce == NULL)) {
35166
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);
35167
0
      if (UNEXPECTED(ce == NULL)) {
35168
35169
0
        HANDLE_EXCEPTION();
35170
0
      }
35171
0
      if (IS_CONST != IS_CONST) {
35172
0
        CACHE_PTR(opline->result.num, ce);
35173
0
      }
35174
0
    }
35175
996
  } else if (IS_UNUSED == IS_UNUSED) {
35176
996
    ce = zend_fetch_class(NULL, opline->op1.num);
35177
996
    if (UNEXPECTED(ce == NULL)) {
35178
35179
7
      HANDLE_EXCEPTION();
35180
7
    }
35181
996
  } else {
35182
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
35183
0
  }
35184
35185
989
  if (IS_UNUSED == IS_CONST &&
35186
989
      IS_CONST == IS_CONST &&
35187
989
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
35188
    /* nothing to do */
35189
989
  } else if (IS_UNUSED != IS_CONST &&
35190
989
             IS_CONST == IS_CONST &&
35191
989
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
35192
407
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
35193
582
  } else if (IS_CONST != IS_UNUSED) {
35194
582
    function_name = RT_CONSTANT(opline, opline->op2);
35195
582
    if (IS_CONST != IS_CONST) {
35196
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
35197
0
        do {
35198
0
          if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
35199
0
            function_name = Z_REFVAL_P(function_name);
35200
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
35201
0
              break;
35202
0
            }
35203
0
          } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
35204
0
            ZVAL_UNDEFINED_OP2();
35205
0
            if (UNEXPECTED(EG(exception) != NULL)) {
35206
0
              HANDLE_EXCEPTION();
35207
0
            }
35208
0
          }
35209
0
          zend_throw_error(NULL, "Method name must be a string");
35210
35211
0
          HANDLE_EXCEPTION();
35212
0
        } while (0);
35213
0
      }
35214
0
    }
35215
35216
582
    if (ce->get_static_method) {
35217
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
35218
582
    } else {
35219
582
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
35220
582
    }
35221
582
    if (UNEXPECTED(fbc == NULL)) {
35222
5
      if (EXPECTED(!EG(exception))) {
35223
5
        zend_undefined_method(ce, Z_STR_P(function_name));
35224
5
      }
35225
35226
5
      HANDLE_EXCEPTION();
35227
5
    }
35228
577
    if (IS_CONST == IS_CONST &&
35229
577
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
35230
577
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
35231
493
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
35232
493
    }
35233
577
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35234
270
      init_func_run_time_cache(&fbc->op_array);
35235
270
    }
35236
577
    if (IS_CONST != IS_CONST) {
35237
35238
0
    }
35239
577
  } else {
35240
0
    if (UNEXPECTED(ce->constructor == NULL)) {
35241
0
      zend_throw_error(NULL, "Cannot call constructor");
35242
0
      HANDLE_EXCEPTION();
35243
0
    }
35244
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)) {
35245
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
35246
0
      HANDLE_EXCEPTION();
35247
0
    }
35248
0
    fbc = ce->constructor;
35249
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35250
0
      init_func_run_time_cache(&fbc->op_array);
35251
0
    }
35252
0
  }
35253
35254
984
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
35255
255
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
35256
255
      ce = (zend_class_entry*)Z_OBJ(EX(This));
35257
255
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35258
255
    } else {
35259
0
      zend_non_static_method_call(fbc);
35260
0
      HANDLE_EXCEPTION();
35261
0
    }
35262
729
  } else {
35263
    /* previous opcode is ZEND_FETCH_CLASS */
35264
729
    if (IS_UNUSED == IS_UNUSED
35265
729
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
35266
729
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
35267
518
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
35268
12
        ce = Z_OBJCE(EX(This));
35269
506
      } else {
35270
506
        ce = Z_CE(EX(This));
35271
506
      }
35272
518
    }
35273
729
    call_info = ZEND_CALL_NESTED_FUNCTION;
35274
729
  }
35275
35276
984
  call = zend_vm_stack_push_call_frame(call_info,
35277
984
    fbc, opline->extended_value, ce);
35278
984
  call->prev_execute_data = EX(call);
35279
984
  EX(call) = call;
35280
35281
984
  ZEND_VM_NEXT_OPCODE();
35282
984
}
35283
35284
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35285
51
{
35286
51
  USE_OPLINE
35287
51
  uint32_t arg_num;
35288
35289
51
  if (IS_CONST == IS_CONST) {
35290
51
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
35291
51
    arg_num = zend_get_arg_offset_by_name(
35292
51
      EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
35293
51
    if (UNEXPECTED(arg_num == 0)) {
35294
      /* Treat this as a by-value argument, and throw an error during SEND. */
35295
0
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35296
0
      ZEND_VM_NEXT_OPCODE();
35297
0
    }
35298
51
  } else {
35299
0
    arg_num = opline->op2.num;
35300
0
  }
35301
35302
51
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
35303
27
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
35304
10
      ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35305
17
    } else {
35306
17
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35307
17
    }
35308
27
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
35309
12
    ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35310
12
  } else {
35311
12
    ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35312
12
  }
35313
51
  ZEND_VM_NEXT_OPCODE();
35314
51
}
35315
35316
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35317
35.0k
{
35318
35.0k
  USE_OPLINE
35319
35.0k
  zend_constant *c;
35320
35321
35.0k
  c = CACHED_PTR(opline->extended_value);
35322
35.0k
  if (EXPECTED(c != NULL) && EXPECTED(!IS_SPECIAL_CACHE_VAL(c))) {
35323
511
    ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
35324
511
    ZEND_VM_NEXT_OPCODE();
35325
511
  }
35326
35327
35.0k
  SAVE_OPLINE();
35328
34.5k
  zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC);
35329
34.5k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35330
34.5k
}
35331
35332
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35333
418
{
35334
418
  zend_class_entry *ce, *scope;
35335
418
  zend_class_constant *c;
35336
418
  zval *value, *zv, *constant_zv;
35337
418
  zend_string *constant_name;
35338
418
  USE_OPLINE
35339
35340
418
  SAVE_OPLINE();
35341
35342
418
  do {
35343
418
    if (IS_UNUSED == IS_CONST && IS_CONST == IS_CONST) {
35344
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
35345
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
35346
0
        break;
35347
0
      }
35348
0
    }
35349
418
    if (IS_UNUSED == IS_CONST) {
35350
0
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
35351
0
        ce = CACHED_PTR(opline->extended_value);
35352
0
      } else {
35353
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);
35354
0
        if (UNEXPECTED(ce == NULL)) {
35355
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35356
35357
0
          HANDLE_EXCEPTION();
35358
0
        }
35359
0
        CACHE_PTR(opline->extended_value, ce);
35360
0
      }
35361
418
    } else if (IS_UNUSED == IS_UNUSED) {
35362
418
      ce = zend_fetch_class(NULL, opline->op1.num);
35363
418
      if (UNEXPECTED(ce == NULL)) {
35364
35
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35365
35366
35
        HANDLE_EXCEPTION();
35367
35
      }
35368
418
    } else {
35369
0
      ce = Z_CE_P(EX_VAR(opline->op1.var));
35370
0
    }
35371
383
    if (IS_UNUSED != IS_CONST
35372
383
      && IS_CONST == IS_CONST
35373
383
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
35374
151
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
35375
151
      break;
35376
151
    }
35377
35378
232
    constant_zv = RT_CONSTANT(opline, opline->op2);
35379
232
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
35380
0
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
35381
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
35382
35383
0
      HANDLE_EXCEPTION();
35384
0
    }
35385
232
    constant_name = Z_STR_P(constant_zv);
35386
    /* Magic 'class' for constant OP2 is caught at compile-time */
35387
232
    if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
35388
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
35389
35390
0
      ZEND_VM_NEXT_OPCODE();
35391
0
    }
35392
232
    zv = IS_CONST == IS_CONST
35393
232
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
35394
232
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
35395
35396
232
    if (EXPECTED(zv != NULL)) {
35397
215
      c = Z_PTR_P(zv);
35398
215
      scope = EX(func)->op_array.scope;
35399
215
      if (!zend_verify_const_access(c, scope)) {
35400
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));
35401
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35402
35403
0
        HANDLE_EXCEPTION();
35404
0
      }
35405
35406
215
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
35407
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35408
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35409
35410
0
        HANDLE_EXCEPTION();
35411
0
      }
35412
35413
215
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
35414
215
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
35415
0
        if (c->ce->type == ZEND_USER_CLASS) {
35416
          /* Recursion protection only applied to user constants, GH-18463 */
35417
0
          CONST_PROTECT_RECURSION(c);
35418
0
        }
35419
0
        zend_deprecated_class_constant(c, constant_name);
35420
0
        if (c->ce->type == ZEND_USER_CLASS) {
35421
0
          CONST_UNPROTECT_RECURSION(c);
35422
0
        }
35423
35424
0
        if (EG(exception)) {
35425
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35426
35427
0
          HANDLE_EXCEPTION();
35428
0
        }
35429
0
      }
35430
35431
215
      value = &c->value;
35432
      // Enums require loading of all class constants to build the backed enum table
35433
215
      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)) {
35434
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
35435
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35436
35437
0
          HANDLE_EXCEPTION();
35438
0
        }
35439
0
      }
35440
215
      if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
35441
24
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
35442
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35443
35444
0
          HANDLE_EXCEPTION();
35445
0
        }
35446
24
      }
35447
215
      if (IS_CONST == IS_CONST && !is_constant_deprecated) {
35448
215
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
35449
215
      }
35450
215
    } else {
35451
17
      zend_throw_error(NULL, "Undefined constant %s::%s",
35452
17
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35453
17
      ZVAL_UNDEF(EX_VAR(opline->result.var));
35454
35455
17
      HANDLE_EXCEPTION();
35456
17
    }
35457
232
  } while (0);
35458
35459
366
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
35460
35461
366
  ZEND_VM_NEXT_OPCODE();
35462
366
}
35463
35464
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35465
0
{
35466
0
  zval *array;
35467
0
  uint32_t size;
35468
0
  USE_OPLINE
35469
35470
0
  SAVE_OPLINE();
35471
0
  array = EX_VAR(opline->result.var);
35472
0
  if (IS_UNUSED != IS_UNUSED) {
35473
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
35474
0
    ZVAL_ARR(array, zend_new_array(size));
35475
    /* Explicitly initialize array as not-packed if flag is set */
35476
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
35477
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
35478
0
    }
35479
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35480
0
  } else {
35481
0
    ZVAL_ARR(array, zend_new_array(0));
35482
0
    ZEND_VM_NEXT_OPCODE();
35483
0
  }
35484
0
}
35485
35486
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35487
435
{
35488
435
  USE_OPLINE
35489
435
  zval *container;
35490
435
  zval *offset;
35491
435
  zend_string *name, *tmp_name;
35492
35493
435
  SAVE_OPLINE();
35494
435
  container = &EX(This);
35495
435
  offset = RT_CONSTANT(opline, opline->op2);
35496
35497
435
  do {
35498
435
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
35499
0
      if (Z_ISREF_P(container)) {
35500
0
        container = Z_REFVAL_P(container);
35501
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
35502
0
          if (IS_UNUSED == IS_CV
35503
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
35504
0
            ZVAL_UNDEFINED_OP1();
35505
0
          }
35506
0
          break;
35507
0
        }
35508
0
      } else {
35509
0
        break;
35510
0
      }
35511
0
    }
35512
435
    if (IS_CONST == IS_CONST) {
35513
435
      name = Z_STR_P(offset);
35514
435
    } else {
35515
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
35516
0
      if (UNEXPECTED(!name)) {
35517
0
        break;
35518
0
      }
35519
0
    }
35520
435
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
35521
435
    if (IS_CONST != IS_CONST) {
35522
0
      zend_tmp_string_release(tmp_name);
35523
0
    }
35524
435
  } while (0);
35525
35526
35527
435
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35528
435
}
35529
35530
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35531
120
{
35532
120
  USE_OPLINE
35533
120
  zval *container;
35534
120
  int result;
35535
120
  zval *offset;
35536
120
  zend_string *name, *tmp_name;
35537
35538
120
  SAVE_OPLINE();
35539
120
  container = &EX(This);
35540
120
  offset = RT_CONSTANT(opline, opline->op2);
35541
35542
120
  if (IS_UNUSED == IS_CONST ||
35543
120
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35544
0
    if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35545
0
      container = Z_REFVAL_P(container);
35546
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
35547
0
        result = (opline->extended_value & ZEND_ISEMPTY);
35548
0
        goto isset_object_finish;
35549
0
      }
35550
0
    } else {
35551
0
      result = (opline->extended_value & ZEND_ISEMPTY);
35552
0
      goto isset_object_finish;
35553
0
    }
35554
0
  }
35555
35556
120
  if (IS_CONST == IS_CONST) {
35557
120
    name = Z_STR_P(offset);
35558
120
  } else {
35559
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
35560
0
    if (UNEXPECTED(!name)) {
35561
0
      result = 0;
35562
0
      goto isset_object_finish;
35563
0
    }
35564
0
  }
35565
35566
120
  result =
35567
120
    (opline->extended_value & ZEND_ISEMPTY) ^
35568
120
    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));
35569
35570
120
  if (IS_CONST != IS_CONST) {
35571
0
    zend_tmp_string_release(tmp_name);
35572
0
  }
35573
35574
120
isset_object_finish:
35575
35576
35577
120
  ZEND_VM_SMART_BRANCH(result, 1);
35578
120
}
35579
35580
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35581
0
{
35582
0
  USE_OPLINE
35583
35584
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
35585
35586
0
  SAVE_OPLINE();
35587
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
35588
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35589
0
  }
35590
35591
  /* Destroy the previously yielded value */
35592
0
  zval_ptr_dtor(&generator->value);
35593
35594
  /* Destroy the previously yielded key */
35595
0
  zval_ptr_dtor(&generator->key);
35596
35597
  /* Set the new yielded value */
35598
0
  if (IS_UNUSED != IS_UNUSED) {
35599
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
35600
      /* Constants and temporary variables aren't yieldable by reference,
35601
       * but we still allow them with a notice. */
35602
0
      if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
35603
0
        zval *value;
35604
35605
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35606
35607
0
        value = NULL;
35608
0
        ZVAL_COPY_VALUE(&generator->value, value);
35609
0
        if (IS_UNUSED == IS_CONST) {
35610
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
35611
0
            Z_ADDREF(generator->value);
35612
0
          }
35613
0
        }
35614
0
      } else {
35615
0
        zval *value_ptr = NULL;
35616
35617
        /* If a function call result is yielded and the function did
35618
         * not return by reference we throw a notice. */
35619
0
        do {
35620
0
          if (IS_UNUSED == IS_VAR) {
35621
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
35622
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
35623
0
             && !Z_ISREF_P(value_ptr)) {
35624
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35625
0
              ZVAL_COPY(&generator->value, value_ptr);
35626
0
              break;
35627
0
            }
35628
0
          }
35629
0
          if (Z_ISREF_P(value_ptr)) {
35630
0
            Z_ADDREF_P(value_ptr);
35631
0
          } else {
35632
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
35633
0
          }
35634
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
35635
0
        } while (0);
35636
35637
0
      }
35638
0
    } else {
35639
0
      zval *value = NULL;
35640
35641
      /* Consts, temporary variables and references need copying */
35642
0
      if (IS_UNUSED == IS_CONST) {
35643
0
        ZVAL_COPY_VALUE(&generator->value, value);
35644
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
35645
0
          Z_ADDREF(generator->value);
35646
0
        }
35647
0
      } else if (IS_UNUSED == IS_TMP_VAR) {
35648
0
        ZVAL_COPY_VALUE(&generator->value, value);
35649
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
35650
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
35651
35652
0
      } else {
35653
0
        ZVAL_COPY_VALUE(&generator->value, value);
35654
0
        if (IS_UNUSED == IS_CV) {
35655
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
35656
0
        }
35657
0
      }
35658
0
    }
35659
0
  } else {
35660
    /* If no value was specified yield null */
35661
0
    ZVAL_NULL(&generator->value);
35662
0
  }
35663
35664
  /* Set the new yielded key */
35665
0
  if (IS_CONST != IS_UNUSED) {
35666
0
    zval *key = RT_CONSTANT(opline, opline->op2);
35667
0
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
35668
0
      key = Z_REFVAL_P(key);
35669
0
    }
35670
0
    ZVAL_COPY(&generator->key, key);
35671
35672
0
    if (Z_TYPE(generator->key) == IS_LONG
35673
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
35674
0
    ) {
35675
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
35676
0
    }
35677
0
  } else {
35678
    /* If no key was specified we use auto-increment keys */
35679
0
    generator->largest_used_integer_key++;
35680
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
35681
0
  }
35682
35683
0
  if (RETURN_VALUE_USED(opline)) {
35684
    /* If the return value of yield is used set the send
35685
     * target and initialize it to NULL */
35686
0
    generator->send_target = EX_VAR(opline->result.var);
35687
0
    ZVAL_NULL(generator->send_target);
35688
0
  } else {
35689
0
    generator->send_target = NULL;
35690
0
  }
35691
35692
  /* The GOTO VM uses a local opline variable. We need to set the opline
35693
   * variable in execute_data so we don't resume at an old position. */
35694
0
  SAVE_OPLINE();
35695
35696
0
  ZEND_VM_RETURN();
35697
0
}
35698
35699
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35700
60
{
35701
60
  zend_class_entry *ce, *scope;
35702
60
  zend_class_constant *c;
35703
60
  zval *value, *zv, *constant_zv;
35704
60
  zend_string *constant_name;
35705
60
  USE_OPLINE
35706
35707
60
  SAVE_OPLINE();
35708
35709
60
  do {
35710
60
    if (IS_UNUSED == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
35711
0
      if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
35712
0
        value = CACHED_PTR(opline->extended_value + sizeof(void*));
35713
0
        break;
35714
0
      }
35715
0
    }
35716
60
    if (IS_UNUSED == IS_CONST) {
35717
0
      if (EXPECTED(CACHED_PTR(opline->extended_value))) {
35718
0
        ce = CACHED_PTR(opline->extended_value);
35719
0
      } else {
35720
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);
35721
0
        if (UNEXPECTED(ce == NULL)) {
35722
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35723
0
          FREE_OP(opline->op2_type, opline->op2.var);
35724
0
          HANDLE_EXCEPTION();
35725
0
        }
35726
0
        CACHE_PTR(opline->extended_value, ce);
35727
0
      }
35728
60
    } else if (IS_UNUSED == IS_UNUSED) {
35729
60
      ce = zend_fetch_class(NULL, opline->op1.num);
35730
60
      if (UNEXPECTED(ce == NULL)) {
35731
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35732
0
        FREE_OP(opline->op2_type, opline->op2.var);
35733
0
        HANDLE_EXCEPTION();
35734
0
      }
35735
60
    } else {
35736
0
      ce = Z_CE_P(EX_VAR(opline->op1.var));
35737
0
    }
35738
60
    if (IS_UNUSED != IS_CONST
35739
60
      && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
35740
60
      && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
35741
0
      value = CACHED_PTR(opline->extended_value + sizeof(void*));
35742
0
      break;
35743
0
    }
35744
35745
60
    constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
35746
60
    if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
35747
0
      zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
35748
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
35749
0
      FREE_OP(opline->op2_type, opline->op2.var);
35750
0
      HANDLE_EXCEPTION();
35751
0
    }
35752
60
    constant_name = Z_STR_P(constant_zv);
35753
    /* Magic 'class' for constant OP2 is caught at compile-time */
35754
60
    if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
35755
30
      ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
35756
30
      FREE_OP(opline->op2_type, opline->op2.var);
35757
30
      ZEND_VM_NEXT_OPCODE();
35758
30
    }
35759
30
    zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
35760
30
      ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
35761
30
      : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
35762
35763
30
    if (EXPECTED(zv != NULL)) {
35764
30
      c = Z_PTR_P(zv);
35765
30
      scope = EX(func)->op_array.scope;
35766
30
      if (!zend_verify_const_access(c, scope)) {
35767
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));
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
      if (ce->ce_flags & ZEND_ACC_TRAIT) {
35774
0
        zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35775
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
35776
0
        FREE_OP(opline->op2_type, opline->op2.var);
35777
0
        HANDLE_EXCEPTION();
35778
0
      }
35779
35780
30
      bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
35781
30
      if (UNEXPECTED(is_constant_deprecated) && !CONST_IS_RECURSIVE(c)) {
35782
0
        if (c->ce->type == ZEND_USER_CLASS) {
35783
          /* Recursion protection only applied to user constants, GH-18463 */
35784
0
          CONST_PROTECT_RECURSION(c);
35785
0
        }
35786
0
        zend_deprecated_class_constant(c, constant_name);
35787
0
        if (c->ce->type == ZEND_USER_CLASS) {
35788
0
          CONST_UNPROTECT_RECURSION(c);
35789
0
        }
35790
35791
0
        if (EG(exception)) {
35792
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35793
0
          FREE_OP(opline->op2_type, opline->op2.var);
35794
0
          HANDLE_EXCEPTION();
35795
0
        }
35796
0
      }
35797
35798
30
      value = &c->value;
35799
      // Enums require loading of all class constants to build the backed enum table
35800
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)) {
35801
0
        if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
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 (Z_TYPE_P(value) == IS_CONSTANT_AST) {
35808
0
        if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
35809
0
          ZVAL_UNDEF(EX_VAR(opline->result.var));
35810
0
          FREE_OP(opline->op2_type, opline->op2.var);
35811
0
          HANDLE_EXCEPTION();
35812
0
        }
35813
0
      }
35814
30
      if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
35815
0
        CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
35816
0
      }
35817
30
    } else {
35818
0
      zend_throw_error(NULL, "Undefined constant %s::%s",
35819
0
        ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35820
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
35821
0
      FREE_OP(opline->op2_type, opline->op2.var);
35822
0
      HANDLE_EXCEPTION();
35823
0
    }
35824
30
  } while (0);
35825
35826
30
  ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
35827
35828
30
  FREE_OP(opline->op2_type, opline->op2.var);
35829
30
  ZEND_VM_NEXT_OPCODE();
35830
30
}
35831
35832
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35833
0
{
35834
0
  USE_OPLINE
35835
0
  zval *object;
35836
0
  zval *property;
35837
0
  zval *value;
35838
0
  zval *zptr;
35839
0
  void *_cache_slot[3] = {0};
35840
0
  void **cache_slot;
35841
0
  zend_property_info *prop_info;
35842
0
  zend_object *zobj;
35843
0
  zend_string *name, *tmp_name;
35844
35845
0
  SAVE_OPLINE();
35846
0
  object = &EX(This);
35847
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35848
35849
0
  do {
35850
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
35851
35852
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35853
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35854
0
        object = Z_REFVAL_P(object);
35855
0
        goto assign_op_object;
35856
0
      }
35857
0
      if (IS_UNUSED == IS_CV
35858
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35859
0
        ZVAL_UNDEFINED_OP1();
35860
0
      }
35861
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35862
0
      break;
35863
0
    }
35864
35865
0
assign_op_object:
35866
    /* here we are sure we are dealing with an object */
35867
0
    zobj = Z_OBJ_P(object);
35868
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35869
0
      name = Z_STR_P(property);
35870
0
    } else {
35871
0
      name = zval_try_get_tmp_string(property, &tmp_name);
35872
0
      if (UNEXPECTED(!name)) {
35873
0
        UNDEF_RESULT();
35874
0
        break;
35875
0
      }
35876
0
    }
35877
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
35878
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35879
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35880
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35881
0
          ZVAL_NULL(EX_VAR(opline->result.var));
35882
0
        }
35883
0
      } else {
35884
0
        zend_reference *ref;
35885
35886
0
        do {
35887
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
35888
0
            ref = Z_REF_P(zptr);
35889
0
            zptr = Z_REFVAL_P(zptr);
35890
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
35891
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
35892
0
              break;
35893
0
            }
35894
0
          }
35895
35896
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
35897
0
          if (prop_info) {
35898
            /* special case for typed properties */
35899
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
35900
0
          } else {
35901
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
35902
0
          }
35903
0
        } while (0);
35904
35905
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35906
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
35907
0
        }
35908
0
      }
35909
0
    } else {
35910
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
35911
0
    }
35912
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35913
0
      zend_tmp_string_release(tmp_name);
35914
0
    }
35915
0
  } while (0);
35916
35917
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
35918
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35919
35920
  /* assign_obj has two opcodes! */
35921
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
35922
0
}
35923
35924
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
35925
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35926
0
{
35927
0
  USE_OPLINE
35928
0
  zval *object;
35929
0
  zval *property;
35930
0
  zval *zptr;
35931
0
  void *_cache_slot[3] = {0};
35932
0
  void **cache_slot;
35933
0
  zend_property_info *prop_info;
35934
0
  zend_object *zobj;
35935
0
  zend_string *name, *tmp_name;
35936
35937
0
  SAVE_OPLINE();
35938
0
  object = &EX(This);
35939
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35940
35941
0
  do {
35942
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35943
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35944
0
        object = Z_REFVAL_P(object);
35945
0
        goto pre_incdec_object;
35946
0
      }
35947
0
      if (IS_UNUSED == IS_CV
35948
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35949
0
        ZVAL_UNDEFINED_OP1();
35950
0
      }
35951
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35952
0
      break;
35953
0
    }
35954
35955
0
pre_incdec_object:
35956
    /* here we are sure we are dealing with an object */
35957
0
    zobj = Z_OBJ_P(object);
35958
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35959
0
      name = Z_STR_P(property);
35960
0
    } else {
35961
0
      name = zval_try_get_tmp_string(property, &tmp_name);
35962
0
      if (UNEXPECTED(!name)) {
35963
0
        UNDEF_RESULT();
35964
0
        break;
35965
0
      }
35966
0
    }
35967
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
35968
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35969
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35970
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35971
0
          ZVAL_NULL(EX_VAR(opline->result.var));
35972
0
        }
35973
0
      } else {
35974
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
35975
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35976
0
      }
35977
0
    } else {
35978
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35979
0
    }
35980
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35981
0
      zend_tmp_string_release(tmp_name);
35982
0
    }
35983
0
  } while (0);
35984
35985
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35986
35987
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35988
0
}
35989
35990
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35991
0
{
35992
0
  USE_OPLINE
35993
0
  zval *object;
35994
0
  zval *property;
35995
0
  zval *zptr;
35996
0
  void *_cache_slot[3] = {0};
35997
0
  void **cache_slot;
35998
0
  zend_property_info *prop_info;
35999
0
  zend_object *zobj;
36000
0
  zend_string *name, *tmp_name;
36001
36002
0
  SAVE_OPLINE();
36003
0
  object = &EX(This);
36004
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36005
36006
0
  do {
36007
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36008
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36009
0
        object = Z_REFVAL_P(object);
36010
0
        goto post_incdec_object;
36011
0
      }
36012
0
      if (IS_UNUSED == IS_CV
36013
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
36014
0
        ZVAL_UNDEFINED_OP1();
36015
0
      }
36016
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
36017
0
      break;
36018
0
    }
36019
36020
0
post_incdec_object:
36021
    /* here we are sure we are dealing with an object */
36022
0
    zobj = Z_OBJ_P(object);
36023
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36024
0
      name = Z_STR_P(property);
36025
0
    } else {
36026
0
      name = zval_try_get_tmp_string(property, &tmp_name);
36027
0
      if (UNEXPECTED(!name)) {
36028
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
36029
0
        break;
36030
0
      }
36031
0
    }
36032
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
36033
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
36034
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
36035
0
        ZVAL_NULL(EX_VAR(opline->result.var));
36036
0
      } else {
36037
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
36038
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
36039
0
      }
36040
0
    } else {
36041
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
36042
0
    }
36043
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36044
0
      zend_tmp_string_release(tmp_name);
36045
0
    }
36046
0
  } while (0);
36047
36048
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36049
36050
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36051
0
}
36052
36053
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36054
1.47k
{
36055
1.47k
  USE_OPLINE
36056
1.47k
  zval *container;
36057
1.47k
  void **cache_slot = NULL;
36058
36059
1.47k
  SAVE_OPLINE();
36060
1.47k
  container = &EX(This);
36061
36062
1.47k
  if (IS_UNUSED == IS_CONST ||
36063
1.47k
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
36064
0
    do {
36065
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
36066
0
        container = Z_REFVAL_P(container);
36067
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
36068
0
          break;
36069
0
        }
36070
0
      }
36071
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
36072
0
        ZVAL_UNDEFINED_OP1();
36073
0
      }
36074
0
      zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36075
0
      ZVAL_NULL(EX_VAR(opline->result.var));
36076
0
      goto fetch_obj_r_finish;
36077
0
    } while (0);
36078
0
  }
36079
36080
  /* here we are sure we are dealing with an object */
36081
1.47k
  do {
36082
1.47k
    zend_object *zobj = Z_OBJ_P(container);
36083
1.47k
    zend_string *name, *tmp_name;
36084
1.47k
    zval *retval;
36085
36086
1.47k
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36087
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
36088
36089
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
36090
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36091
36092
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36093
0
fetch_obj_r_simple:
36094
0
          retval = OBJ_PROP(zobj, prop_offset);
36095
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
36096
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36097
0
              goto fetch_obj_r_copy;
36098
0
            } else {
36099
0
fetch_obj_r_fast_copy:
36100
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36101
0
              ZEND_VM_NEXT_OPCODE();
36102
0
            }
36103
0
          }
36104
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
36105
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36106
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
36107
0
            prop_offset = prop_info->offset;
36108
0
            goto fetch_obj_r_simple;
36109
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
36110
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
36111
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
36112
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
36113
36114
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
36115
0
            if (IS_UNUSED & IS_CV) {
36116
0
              GC_ADDREF(zobj);
36117
0
            }
36118
0
            if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
36119
0
              call_info |= ZEND_CALL_RELEASE_THIS;
36120
0
            }
36121
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
36122
0
            call->prev_execute_data = execute_data;
36123
0
            call->call = NULL;
36124
0
            call->return_value = EX_VAR(opline->result.var);
36125
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
36126
36127
0
            execute_data = call;
36128
0
            EG(current_execute_data) = execute_data;
36129
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
36130
36131
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
36132
            opline = hook->op_array.opcodes;
36133
#else
36134
0
            EX(opline) = hook->op_array.opcodes;
36135
0
#endif
36136
0
            LOAD_OPLINE_EX();
36137
36138
36139
0
            ZEND_VM_ENTER_EX();
36140
0
          }
36141
          /* Fall through to read_property for hooks. */
36142
0
        } else if (EXPECTED(zobj->properties != NULL)) {
36143
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
36144
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36145
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
36146
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
36147
36148
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
36149
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
36150
36151
0
              if (EXPECTED(p->key == name) ||
36152
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
36153
0
                   EXPECTED(p->key != NULL) &&
36154
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
36155
0
                retval = &p->val;
36156
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36157
0
                  goto fetch_obj_r_copy;
36158
0
                } else {
36159
0
                  goto fetch_obj_r_fast_copy;
36160
0
                }
36161
0
              }
36162
0
            }
36163
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
36164
0
          }
36165
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
36166
0
          if (EXPECTED(retval)) {
36167
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
36168
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
36169
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36170
0
              goto fetch_obj_r_copy;
36171
0
            } else {
36172
0
              goto fetch_obj_r_fast_copy;
36173
0
            }
36174
0
          }
36175
0
        }
36176
0
      }
36177
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36178
1.47k
    } else {
36179
1.47k
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36180
1.47k
      if (UNEXPECTED(!name)) {
36181
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
36182
0
        break;
36183
0
      }
36184
1.47k
    }
36185
36186
1.47k
#if ZEND_DEBUG
36187
    /* For non-standard object handlers, verify a declared property type in debug builds.
36188
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
36189
1.47k
    zend_property_info *prop_info = NULL;
36190
1.47k
    if (zobj->handlers->read_property != zend_std_read_property) {
36191
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
36192
0
    }
36193
1.47k
#endif
36194
1.47k
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
36195
1.47k
#if ZEND_DEBUG
36196
1.47k
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
36197
1.47k
        && ZEND_TYPE_IS_SET(prop_info->type)) {
36198
0
      ZVAL_OPT_DEREF(retval);
36199
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
36200
0
    }
36201
1.47k
#endif
36202
36203
1.47k
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36204
10
      zend_tmp_string_release(tmp_name);
36205
10
    }
36206
36207
1.47k
    if (retval != EX_VAR(opline->result.var)) {
36208
5
fetch_obj_r_copy:
36209
5
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36210
1.46k
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
36211
0
      zend_unwrap_reference(retval);
36212
0
    }
36213
1.47k
  } while (0);
36214
36215
1.47k
fetch_obj_r_finish:
36216
10
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36217
36218
10
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36219
10
}
36220
36221
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36222
0
{
36223
0
  USE_OPLINE
36224
0
  zval *property, *container, *result;
36225
36226
0
  SAVE_OPLINE();
36227
36228
0
  container = &EX(This);
36229
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36230
0
  result = EX_VAR(opline->result.var);
36231
0
  zend_fetch_property_address(
36232
0
    result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR),
36233
0
    (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
36234
0
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
36235
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36236
0
  if (IS_UNUSED == IS_VAR) {
36237
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36238
0
  }
36239
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36240
0
}
36241
36242
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36243
0
{
36244
0
  USE_OPLINE
36245
0
  zval *property, *container, *result;
36246
36247
0
  SAVE_OPLINE();
36248
0
  container = &EX(This);
36249
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36250
0
  result = EX_VAR(opline->result.var);
36251
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);
36252
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36253
0
  if (IS_UNUSED == IS_VAR) {
36254
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36255
0
  }
36256
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36257
0
}
36258
36259
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36260
0
{
36261
0
  USE_OPLINE
36262
0
  zval *container;
36263
0
  void **cache_slot = NULL;
36264
36265
0
  SAVE_OPLINE();
36266
0
  container = &EX(This);
36267
36268
0
  if (IS_UNUSED == IS_CONST ||
36269
0
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
36270
0
    do {
36271
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
36272
0
        container = Z_REFVAL_P(container);
36273
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
36274
0
          break;
36275
0
        }
36276
0
      }
36277
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
36278
0
        ZVAL_UNDEFINED_OP2();
36279
0
      }
36280
0
      ZVAL_NULL(EX_VAR(opline->result.var));
36281
0
      goto fetch_obj_is_finish;
36282
0
    } while (0);
36283
0
  }
36284
36285
  /* here we are sure we are dealing with an object */
36286
0
  do {
36287
0
    zend_object *zobj = Z_OBJ_P(container);
36288
0
    zend_string *name, *tmp_name;
36289
0
    zval *retval;
36290
36291
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36292
0
      cache_slot = CACHE_ADDR(opline->extended_value);
36293
36294
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
36295
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36296
36297
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36298
0
fetch_obj_is_simple:
36299
0
          retval = OBJ_PROP(zobj, prop_offset);
36300
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
36301
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36302
0
              goto fetch_obj_is_copy;
36303
0
            } else {
36304
0
fetch_obj_is_fast_copy:
36305
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36306
0
              ZEND_VM_NEXT_OPCODE();
36307
0
            }
36308
0
          }
36309
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
36310
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
36311
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36312
0
            prop_offset = prop_info->offset;
36313
0
            goto fetch_obj_is_simple;
36314
0
          }
36315
          /* Fall through to read_property for hooks. */
36316
0
        } else if (EXPECTED(zobj->properties != NULL)) {
36317
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
36318
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36319
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
36320
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
36321
36322
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
36323
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
36324
36325
0
              if (EXPECTED(p->key == name) ||
36326
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
36327
0
                   EXPECTED(p->key != NULL) &&
36328
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
36329
0
                retval = &p->val;
36330
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36331
0
                  goto fetch_obj_is_copy;
36332
0
                } else {
36333
0
                  goto fetch_obj_is_fast_copy;
36334
0
                }
36335
0
              }
36336
0
            }
36337
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
36338
0
          }
36339
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
36340
0
          if (EXPECTED(retval)) {
36341
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
36342
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
36343
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36344
0
              goto fetch_obj_is_copy;
36345
0
            } else {
36346
0
              goto fetch_obj_is_fast_copy;
36347
0
            }
36348
0
          }
36349
0
        }
36350
0
      }
36351
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36352
0
    } else {
36353
0
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36354
0
      if (UNEXPECTED(!name)) {
36355
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
36356
0
        break;
36357
0
      }
36358
0
    }
36359
36360
0
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
36361
36362
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36363
0
      zend_tmp_string_release(tmp_name);
36364
0
    }
36365
36366
0
    if (retval != EX_VAR(opline->result.var)) {
36367
0
fetch_obj_is_copy:
36368
0
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36369
0
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
36370
0
      zend_unwrap_reference(retval);
36371
0
    }
36372
0
  } while (0);
36373
36374
0
fetch_obj_is_finish:
36375
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36376
36377
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36378
0
}
36379
36380
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36381
0
{
36382
#if 0
36383
  USE_OPLINE
36384
#endif
36385
36386
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
36387
    /* Behave like FETCH_OBJ_W */
36388
0
    if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
36389
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36390
0
    }
36391
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36392
0
  } else {
36393
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36394
0
  }
36395
0
}
36396
36397
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36398
0
{
36399
0
  USE_OPLINE
36400
0
  zval *container, *property, *result;
36401
36402
0
  SAVE_OPLINE();
36403
0
  container = &EX(This);
36404
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36405
0
  result = EX_VAR(opline->result.var);
36406
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);
36407
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36408
0
  if (IS_UNUSED == IS_VAR) {
36409
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36410
0
  }
36411
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36412
0
}
36413
36414
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36415
0
{
36416
0
  USE_OPLINE
36417
0
  zval *object, *value, tmp;
36418
0
  zend_object *zobj;
36419
0
  zend_string *name, *tmp_name;
36420
0
  zend_refcounted *garbage = NULL;
36421
36422
0
  SAVE_OPLINE();
36423
0
  object = &EX(This);
36424
0
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
36425
36426
0
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36427
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36428
0
      object = Z_REFVAL_P(object);
36429
0
      goto assign_object;
36430
0
    }
36431
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36432
0
    value = &EG(uninitialized_zval);
36433
0
    goto free_and_exit_assign_obj;
36434
0
  }
36435
36436
0
assign_object:
36437
0
  zobj = Z_OBJ_P(object);
36438
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36439
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36440
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
36441
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36442
0
      zval *property_val;
36443
0
      zend_property_info *prop_info;
36444
36445
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36446
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36447
36448
0
assign_obj_simple:
36449
0
        property_val = OBJ_PROP(zobj, prop_offset);
36450
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
36451
0
          if (prop_info != NULL) {
36452
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36453
0
            goto free_and_exit_assign_obj;
36454
0
          } else {
36455
0
fast_assign_obj:
36456
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
36457
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36458
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
36459
0
            }
36460
0
            goto exit_assign_obj;
36461
0
          }
36462
0
        }
36463
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36464
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36465
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36466
0
          zobj = zend_lazy_object_init(zobj);
36467
0
          if (!zobj) {
36468
0
            value = &EG(uninitialized_zval);
36469
0
            goto free_and_exit_assign_obj;
36470
0
          }
36471
0
        }
36472
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36473
0
          rebuild_object_properties_internal(zobj);
36474
0
        }
36475
0
        if (EXPECTED(zobj->properties != NULL)) {
36476
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36477
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36478
0
              GC_DELREF(zobj->properties);
36479
0
            }
36480
0
            zobj->properties = zend_array_dup(zobj->properties);
36481
0
          }
36482
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
36483
0
          if (property_val) {
36484
0
            goto fast_assign_obj;
36485
0
          }
36486
0
        }
36487
36488
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36489
0
          if (IS_CONST == IS_CONST) {
36490
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36491
0
              Z_ADDREF_P(value);
36492
0
            }
36493
0
          } else if (IS_CONST != IS_TMP_VAR) {
36494
0
            if (Z_ISREF_P(value)) {
36495
0
              if (IS_CONST == IS_VAR) {
36496
0
                zend_reference *ref = Z_REF_P(value);
36497
0
                if (GC_DELREF(ref) == 0) {
36498
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36499
0
                  efree_size(ref, sizeof(zend_reference));
36500
0
                  value = &tmp;
36501
0
                } else {
36502
0
                  value = Z_REFVAL_P(value);
36503
0
                  Z_TRY_ADDREF_P(value);
36504
0
                }
36505
0
              } else {
36506
0
                value = Z_REFVAL_P(value);
36507
0
                Z_TRY_ADDREF_P(value);
36508
0
              }
36509
0
            } else if (IS_CONST == IS_CV) {
36510
0
              Z_TRY_ADDREF_P(value);
36511
0
            }
36512
0
          }
36513
0
          zend_hash_add_new(zobj->properties, name, value);
36514
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36515
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
36516
0
          }
36517
0
          goto exit_assign_obj;
36518
0
        }
36519
0
      } else {
36520
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36521
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36522
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
36523
0
          prop_offset = prop_info->offset;
36524
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36525
0
            prop_info = NULL;
36526
0
          }
36527
0
          goto assign_obj_simple;
36528
0
        }
36529
        /* Fall through to write_property for hooks. */
36530
0
      }
36531
0
    }
36532
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36533
0
  } else {
36534
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36535
0
    if (UNEXPECTED(!name)) {
36536
36537
0
      UNDEF_RESULT();
36538
0
      goto exit_assign_obj;
36539
0
    }
36540
0
  }
36541
36542
0
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
36543
0
    ZVAL_DEREF(value);
36544
0
  }
36545
36546
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36547
36548
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36549
0
    zend_tmp_string_release(tmp_name);
36550
0
  }
36551
36552
0
free_and_exit_assign_obj:
36553
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36554
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36555
0
  }
36556
36557
0
exit_assign_obj:
36558
0
  if (garbage) {
36559
0
    GC_DTOR_NO_REF(garbage);
36560
0
  }
36561
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36562
36563
  /* assign_obj has two opcodes! */
36564
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
36565
0
}
36566
36567
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36568
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36569
2
{
36570
2
  USE_OPLINE
36571
2
  zval *object, *value, tmp;
36572
2
  zend_object *zobj;
36573
2
  zend_string *name, *tmp_name;
36574
2
  zend_refcounted *garbage = NULL;
36575
36576
2
  SAVE_OPLINE();
36577
2
  object = &EX(This);
36578
2
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
36579
36580
2
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36581
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36582
0
      object = Z_REFVAL_P(object);
36583
0
      goto assign_object;
36584
0
    }
36585
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36586
0
    value = &EG(uninitialized_zval);
36587
0
    goto free_and_exit_assign_obj;
36588
0
  }
36589
36590
2
assign_object:
36591
2
  zobj = Z_OBJ_P(object);
36592
2
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36593
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36594
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
36595
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36596
0
      zval *property_val;
36597
0
      zend_property_info *prop_info;
36598
36599
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36600
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36601
36602
0
assign_obj_simple:
36603
0
        property_val = OBJ_PROP(zobj, prop_offset);
36604
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
36605
0
          if (prop_info != NULL) {
36606
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36607
0
            goto free_and_exit_assign_obj;
36608
0
          } else {
36609
0
fast_assign_obj:
36610
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
36611
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36612
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
36613
0
            }
36614
0
            goto exit_assign_obj;
36615
0
          }
36616
0
        }
36617
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36618
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36619
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36620
0
          zobj = zend_lazy_object_init(zobj);
36621
0
          if (!zobj) {
36622
0
            value = &EG(uninitialized_zval);
36623
0
            goto free_and_exit_assign_obj;
36624
0
          }
36625
0
        }
36626
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36627
0
          rebuild_object_properties_internal(zobj);
36628
0
        }
36629
0
        if (EXPECTED(zobj->properties != NULL)) {
36630
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36631
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36632
0
              GC_DELREF(zobj->properties);
36633
0
            }
36634
0
            zobj->properties = zend_array_dup(zobj->properties);
36635
0
          }
36636
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
36637
0
          if (property_val) {
36638
0
            goto fast_assign_obj;
36639
0
          }
36640
0
        }
36641
36642
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36643
0
          if (IS_TMP_VAR == IS_CONST) {
36644
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36645
0
              Z_ADDREF_P(value);
36646
0
            }
36647
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
36648
0
            if (Z_ISREF_P(value)) {
36649
0
              if (IS_TMP_VAR == IS_VAR) {
36650
0
                zend_reference *ref = Z_REF_P(value);
36651
0
                if (GC_DELREF(ref) == 0) {
36652
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36653
0
                  efree_size(ref, sizeof(zend_reference));
36654
0
                  value = &tmp;
36655
0
                } else {
36656
0
                  value = Z_REFVAL_P(value);
36657
0
                  Z_TRY_ADDREF_P(value);
36658
0
                }
36659
0
              } else {
36660
0
                value = Z_REFVAL_P(value);
36661
0
                Z_TRY_ADDREF_P(value);
36662
0
              }
36663
0
            } else if (IS_TMP_VAR == IS_CV) {
36664
0
              Z_TRY_ADDREF_P(value);
36665
0
            }
36666
0
          }
36667
0
          zend_hash_add_new(zobj->properties, name, value);
36668
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36669
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
36670
0
          }
36671
0
          goto exit_assign_obj;
36672
0
        }
36673
0
      } else {
36674
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36675
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36676
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
36677
0
          prop_offset = prop_info->offset;
36678
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36679
0
            prop_info = NULL;
36680
0
          }
36681
0
          goto assign_obj_simple;
36682
0
        }
36683
        /* Fall through to write_property for hooks. */
36684
0
      }
36685
0
    }
36686
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36687
2
  } else {
36688
2
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36689
2
    if (UNEXPECTED(!name)) {
36690
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36691
0
      UNDEF_RESULT();
36692
0
      goto exit_assign_obj;
36693
0
    }
36694
2
  }
36695
36696
2
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
36697
0
    ZVAL_DEREF(value);
36698
0
  }
36699
36700
2
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36701
36702
2
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36703
2
    zend_tmp_string_release(tmp_name);
36704
2
  }
36705
36706
2
free_and_exit_assign_obj:
36707
2
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36708
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36709
0
  }
36710
2
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36711
2
exit_assign_obj:
36712
2
  if (garbage) {
36713
0
    GC_DTOR_NO_REF(garbage);
36714
0
  }
36715
2
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36716
36717
  /* assign_obj has two opcodes! */
36718
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
36719
2
}
36720
36721
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36722
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36723
0
{
36724
0
  USE_OPLINE
36725
0
  zval *object, *value, tmp;
36726
0
  zend_object *zobj;
36727
0
  zend_string *name, *tmp_name;
36728
0
  zend_refcounted *garbage = NULL;
36729
36730
0
  SAVE_OPLINE();
36731
0
  object = &EX(This);
36732
0
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
36733
36734
0
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36735
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36736
0
      object = Z_REFVAL_P(object);
36737
0
      goto assign_object;
36738
0
    }
36739
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36740
0
    value = &EG(uninitialized_zval);
36741
0
    goto free_and_exit_assign_obj;
36742
0
  }
36743
36744
0
assign_object:
36745
0
  zobj = Z_OBJ_P(object);
36746
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36747
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36748
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
36749
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36750
0
      zval *property_val;
36751
0
      zend_property_info *prop_info;
36752
36753
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36754
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36755
36756
0
assign_obj_simple:
36757
0
        property_val = OBJ_PROP(zobj, prop_offset);
36758
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
36759
0
          if (prop_info != NULL) {
36760
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36761
0
            goto free_and_exit_assign_obj;
36762
0
          } else {
36763
0
fast_assign_obj:
36764
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
36765
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36766
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
36767
0
            }
36768
0
            goto exit_assign_obj;
36769
0
          }
36770
0
        }
36771
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36772
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36773
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36774
0
          zobj = zend_lazy_object_init(zobj);
36775
0
          if (!zobj) {
36776
0
            value = &EG(uninitialized_zval);
36777
0
            goto free_and_exit_assign_obj;
36778
0
          }
36779
0
        }
36780
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36781
0
          rebuild_object_properties_internal(zobj);
36782
0
        }
36783
0
        if (EXPECTED(zobj->properties != NULL)) {
36784
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36785
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36786
0
              GC_DELREF(zobj->properties);
36787
0
            }
36788
0
            zobj->properties = zend_array_dup(zobj->properties);
36789
0
          }
36790
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
36791
0
          if (property_val) {
36792
0
            goto fast_assign_obj;
36793
0
          }
36794
0
        }
36795
36796
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36797
0
          if (IS_VAR == IS_CONST) {
36798
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36799
0
              Z_ADDREF_P(value);
36800
0
            }
36801
0
          } else if (IS_VAR != IS_TMP_VAR) {
36802
0
            if (Z_ISREF_P(value)) {
36803
0
              if (IS_VAR == IS_VAR) {
36804
0
                zend_reference *ref = Z_REF_P(value);
36805
0
                if (GC_DELREF(ref) == 0) {
36806
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36807
0
                  efree_size(ref, sizeof(zend_reference));
36808
0
                  value = &tmp;
36809
0
                } else {
36810
0
                  value = Z_REFVAL_P(value);
36811
0
                  Z_TRY_ADDREF_P(value);
36812
0
                }
36813
0
              } else {
36814
0
                value = Z_REFVAL_P(value);
36815
0
                Z_TRY_ADDREF_P(value);
36816
0
              }
36817
0
            } else if (IS_VAR == IS_CV) {
36818
0
              Z_TRY_ADDREF_P(value);
36819
0
            }
36820
0
          }
36821
0
          zend_hash_add_new(zobj->properties, name, value);
36822
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36823
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
36824
0
          }
36825
0
          goto exit_assign_obj;
36826
0
        }
36827
0
      } else {
36828
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36829
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36830
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
36831
0
          prop_offset = prop_info->offset;
36832
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36833
0
            prop_info = NULL;
36834
0
          }
36835
0
          goto assign_obj_simple;
36836
0
        }
36837
        /* Fall through to write_property for hooks. */
36838
0
      }
36839
0
    }
36840
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36841
0
  } else {
36842
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36843
0
    if (UNEXPECTED(!name)) {
36844
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36845
0
      UNDEF_RESULT();
36846
0
      goto exit_assign_obj;
36847
0
    }
36848
0
  }
36849
36850
0
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
36851
0
    ZVAL_DEREF(value);
36852
0
  }
36853
36854
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36855
36856
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36857
0
    zend_tmp_string_release(tmp_name);
36858
0
  }
36859
36860
0
free_and_exit_assign_obj:
36861
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36862
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36863
0
  }
36864
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36865
0
exit_assign_obj:
36866
0
  if (garbage) {
36867
0
    GC_DTOR_NO_REF(garbage);
36868
0
  }
36869
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36870
36871
  /* assign_obj has two opcodes! */
36872
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
36873
0
}
36874
36875
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36876
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36877
0
{
36878
0
  USE_OPLINE
36879
0
  zval *object, *value, tmp;
36880
0
  zend_object *zobj;
36881
0
  zend_string *name, *tmp_name;
36882
0
  zend_refcounted *garbage = NULL;
36883
36884
0
  SAVE_OPLINE();
36885
0
  object = &EX(This);
36886
0
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
36887
36888
0
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36889
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36890
0
      object = Z_REFVAL_P(object);
36891
0
      goto assign_object;
36892
0
    }
36893
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36894
0
    value = &EG(uninitialized_zval);
36895
0
    goto free_and_exit_assign_obj;
36896
0
  }
36897
36898
0
assign_object:
36899
0
  zobj = Z_OBJ_P(object);
36900
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36901
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36902
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
36903
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36904
0
      zval *property_val;
36905
0
      zend_property_info *prop_info;
36906
36907
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36908
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36909
36910
0
assign_obj_simple:
36911
0
        property_val = OBJ_PROP(zobj, prop_offset);
36912
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
36913
0
          if (prop_info != NULL) {
36914
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36915
0
            goto free_and_exit_assign_obj;
36916
0
          } else {
36917
0
fast_assign_obj:
36918
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
36919
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36920
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
36921
0
            }
36922
0
            goto exit_assign_obj;
36923
0
          }
36924
0
        }
36925
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36926
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36927
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36928
0
          zobj = zend_lazy_object_init(zobj);
36929
0
          if (!zobj) {
36930
0
            value = &EG(uninitialized_zval);
36931
0
            goto free_and_exit_assign_obj;
36932
0
          }
36933
0
        }
36934
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36935
0
          rebuild_object_properties_internal(zobj);
36936
0
        }
36937
0
        if (EXPECTED(zobj->properties != NULL)) {
36938
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36939
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36940
0
              GC_DELREF(zobj->properties);
36941
0
            }
36942
0
            zobj->properties = zend_array_dup(zobj->properties);
36943
0
          }
36944
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
36945
0
          if (property_val) {
36946
0
            goto fast_assign_obj;
36947
0
          }
36948
0
        }
36949
36950
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36951
0
          if (IS_CV == IS_CONST) {
36952
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36953
0
              Z_ADDREF_P(value);
36954
0
            }
36955
0
          } else if (IS_CV != IS_TMP_VAR) {
36956
0
            if (Z_ISREF_P(value)) {
36957
0
              if (IS_CV == IS_VAR) {
36958
0
                zend_reference *ref = Z_REF_P(value);
36959
0
                if (GC_DELREF(ref) == 0) {
36960
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36961
0
                  efree_size(ref, sizeof(zend_reference));
36962
0
                  value = &tmp;
36963
0
                } else {
36964
0
                  value = Z_REFVAL_P(value);
36965
0
                  Z_TRY_ADDREF_P(value);
36966
0
                }
36967
0
              } else {
36968
0
                value = Z_REFVAL_P(value);
36969
0
                Z_TRY_ADDREF_P(value);
36970
0
              }
36971
0
            } else if (IS_CV == IS_CV) {
36972
0
              Z_TRY_ADDREF_P(value);
36973
0
            }
36974
0
          }
36975
0
          zend_hash_add_new(zobj->properties, name, value);
36976
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36977
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
36978
0
          }
36979
0
          goto exit_assign_obj;
36980
0
        }
36981
0
      } else {
36982
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36983
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36984
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
36985
0
          prop_offset = prop_info->offset;
36986
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36987
0
            prop_info = NULL;
36988
0
          }
36989
0
          goto assign_obj_simple;
36990
0
        }
36991
        /* Fall through to write_property for hooks. */
36992
0
      }
36993
0
    }
36994
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36995
0
  } else {
36996
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36997
0
    if (UNEXPECTED(!name)) {
36998
36999
0
      UNDEF_RESULT();
37000
0
      goto exit_assign_obj;
37001
0
    }
37002
0
  }
37003
37004
0
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
37005
0
    ZVAL_DEREF(value);
37006
0
  }
37007
37008
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
37009
37010
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37011
0
    zend_tmp_string_release(tmp_name);
37012
0
  }
37013
37014
0
free_and_exit_assign_obj:
37015
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
37016
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
37017
0
  }
37018
37019
0
exit_assign_obj:
37020
0
  if (garbage) {
37021
0
    GC_DTOR_NO_REF(garbage);
37022
0
  }
37023
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37024
37025
  /* assign_obj has two opcodes! */
37026
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
37027
0
}
37028
37029
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
37030
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37031
0
{
37032
0
  USE_OPLINE
37033
0
  zval *property, *container, *value_ptr;
37034
37035
0
  SAVE_OPLINE();
37036
37037
0
  container = &EX(This);
37038
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37039
37040
0
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
37041
37042
0
  if (1) {
37043
0
    if (IS_UNUSED == IS_UNUSED) {
37044
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37045
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37046
0
      } else {
37047
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37048
0
      }
37049
0
    } else {
37050
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37051
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37052
0
      } else {
37053
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37054
0
      }
37055
0
    }
37056
0
  } else {
37057
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
37058
0
  }
37059
37060
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37061
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
37062
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
37063
0
}
37064
37065
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
37066
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37067
0
{
37068
0
  USE_OPLINE
37069
0
  zval *property, *container, *value_ptr;
37070
37071
0
  SAVE_OPLINE();
37072
37073
0
  container = &EX(This);
37074
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37075
37076
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
37077
37078
0
  if (1) {
37079
0
    if (IS_UNUSED == IS_UNUSED) {
37080
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37081
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37082
0
      } else {
37083
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37084
0
      }
37085
0
    } else {
37086
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37087
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37088
0
      } else {
37089
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
37090
0
      }
37091
0
    }
37092
0
  } else {
37093
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
37094
0
  }
37095
37096
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37097
37098
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
37099
0
}
37100
37101
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
37102
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37103
457
{
37104
457
  USE_OPLINE
37105
457
  zend_string **rope;
37106
457
  zval *var;
37107
37108
  /* Compiler allocates the necessary number of zval slots to keep the rope */
37109
457
  rope = (zend_string**)EX_VAR(opline->result.var);
37110
457
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37111
0
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37112
0
    rope[0] = Z_STR_P(var);
37113
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
37114
0
      Z_ADDREF_P(var);
37115
0
    }
37116
457
  } else {
37117
457
    var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37118
457
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
37119
82
      if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
37120
0
        rope[0] = zend_string_copy(Z_STR_P(var));
37121
82
      } else {
37122
82
        rope[0] = Z_STR_P(var);
37123
82
      }
37124
375
    } else {
37125
375
      SAVE_OPLINE();
37126
375
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
37127
0
        ZVAL_UNDEFINED_OP2();
37128
0
      }
37129
375
      rope[0] = zval_get_string_func(var);
37130
375
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37131
375
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37132
375
    }
37133
457
  }
37134
82
  ZEND_VM_NEXT_OPCODE();
37135
82
}
37136
37137
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37138
549
{
37139
549
  zval *class_name;
37140
549
  USE_OPLINE
37141
37142
549
  SAVE_OPLINE();
37143
549
  if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
37144
0
    Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
37145
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37146
549
  } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37147
0
    zend_class_entry *ce = CACHED_PTR(opline->extended_value);
37148
37149
0
    if (UNEXPECTED(ce == NULL)) {
37150
0
      class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37151
0
      ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
37152
0
      CACHE_PTR(opline->extended_value, ce);
37153
0
    }
37154
0
    Z_CE_P(EX_VAR(opline->result.var)) = ce;
37155
549
  } else {
37156
549
    class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37157
549
try_class_name:
37158
549
    if (Z_TYPE_P(class_name) == IS_OBJECT) {
37159
302
      Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
37160
302
    } else if (Z_TYPE_P(class_name) == IS_STRING) {
37161
235
      Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
37162
235
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
37163
0
      class_name = Z_REFVAL_P(class_name);
37164
0
      goto try_class_name;
37165
12
    } else {
37166
12
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
37167
0
        ZVAL_UNDEFINED_OP2();
37168
0
        if (UNEXPECTED(EG(exception) != NULL)) {
37169
0
          HANDLE_EXCEPTION();
37170
0
        }
37171
0
      }
37172
12
      zend_throw_error(NULL, "Class name must be a valid object or a string");
37173
12
    }
37174
549
  }
37175
37176
549
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37177
549
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37178
549
}
37179
37180
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37181
629
{
37182
629
  USE_OPLINE
37183
629
  zval *function_name;
37184
629
  zval *object;
37185
629
  zend_function *fbc;
37186
629
  zend_class_entry *called_scope;
37187
629
  zend_object *obj;
37188
629
  zend_execute_data *call;
37189
629
  uint32_t call_info;
37190
37191
629
  SAVE_OPLINE();
37192
37193
629
  object = &EX(This);
37194
37195
629
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37196
629
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37197
629
  }
37198
37199
629
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
37200
629
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37201
0
    do {
37202
0
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
37203
0
        function_name = Z_REFVAL_P(function_name);
37204
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37205
0
          break;
37206
0
        }
37207
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37208
0
        ZVAL_UNDEFINED_OP2();
37209
0
        if (UNEXPECTED(EG(exception) != NULL)) {
37210
37211
0
          HANDLE_EXCEPTION();
37212
0
        }
37213
0
      }
37214
0
      zend_throw_error(NULL, "Method name must be a string");
37215
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37216
37217
0
      HANDLE_EXCEPTION();
37218
0
    } while (0);
37219
0
  }
37220
37221
629
  if (IS_UNUSED == IS_UNUSED) {
37222
629
    obj = Z_OBJ_P(object);
37223
629
  } else {
37224
0
    do {
37225
0
      if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
37226
0
        obj = Z_OBJ_P(object);
37227
0
      } else {
37228
0
        if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
37229
0
          zend_reference *ref = Z_REF_P(object);
37230
37231
0
          object = &ref->val;
37232
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
37233
0
            obj = Z_OBJ_P(object);
37234
0
            if (IS_UNUSED & IS_VAR) {
37235
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
37236
0
                efree_size(ref, sizeof(zend_reference));
37237
0
              } else {
37238
0
                Z_ADDREF_P(object);
37239
0
              }
37240
0
            }
37241
0
            break;
37242
0
          }
37243
0
        }
37244
0
        if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37245
0
          object = ZVAL_UNDEFINED_OP1();
37246
0
          if (UNEXPECTED(EG(exception) != NULL)) {
37247
0
            if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37248
0
              zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37249
0
            }
37250
0
            HANDLE_EXCEPTION();
37251
0
          }
37252
0
        }
37253
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37254
0
          function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37255
0
        }
37256
0
        zend_invalid_method_call(object, function_name);
37257
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37258
37259
0
        HANDLE_EXCEPTION();
37260
0
      }
37261
0
    } while (0);
37262
0
  }
37263
37264
629
  called_scope = obj->ce;
37265
37266
629
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37267
629
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
37268
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37269
629
  } else {
37270
629
    zend_object *orig_obj = obj;
37271
37272
629
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37273
0
      function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37274
0
    }
37275
37276
    /* First, locate the function. */
37277
629
    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));
37278
629
    if (UNEXPECTED(fbc == NULL)) {
37279
0
      if (EXPECTED(!EG(exception))) {
37280
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
37281
0
      }
37282
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37283
0
      if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
37284
0
        zend_objects_store_del(orig_obj);
37285
0
      }
37286
0
      HANDLE_EXCEPTION();
37287
0
    }
37288
629
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37289
629
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37290
629
        EXPECTED(obj == orig_obj)) {
37291
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
37292
0
    }
37293
629
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
37294
0
      GC_ADDREF(obj); /* For $this pointer */
37295
0
      if (GC_DELREF(orig_obj) == 0) {
37296
0
        zend_objects_store_del(orig_obj);
37297
0
      }
37298
0
    }
37299
629
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37300
16
      init_func_run_time_cache(&fbc->op_array);
37301
16
    }
37302
629
  }
37303
37304
629
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37305
629
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37306
629
  }
37307
37308
629
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37309
629
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
37310
0
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
37311
0
      zend_objects_store_del(obj);
37312
0
      if (UNEXPECTED(EG(exception))) {
37313
0
        HANDLE_EXCEPTION();
37314
0
      }
37315
0
    }
37316
    /* call static method */
37317
0
    obj = (zend_object*)called_scope;
37318
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
37319
629
  } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
37320
0
    if (IS_UNUSED == IS_CV) {
37321
0
      GC_ADDREF(obj); /* For $this pointer */
37322
0
    }
37323
    /* CV may be changed indirectly (e.g. when it's a reference) */
37324
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
37325
0
  }
37326
37327
629
  call = zend_vm_stack_push_call_frame(call_info,
37328
629
    fbc, opline->extended_value, obj);
37329
629
  call->prev_execute_data = EX(call);
37330
629
  EX(call) = call;
37331
37332
629
  ZEND_VM_NEXT_OPCODE();
37333
629
}
37334
37335
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37336
5
{
37337
5
  USE_OPLINE
37338
5
  zval *function_name;
37339
5
  zend_class_entry *ce;
37340
5
  uint32_t call_info;
37341
5
  zend_function *fbc;
37342
5
  zend_execute_data *call;
37343
37344
5
  SAVE_OPLINE();
37345
37346
5
  if (IS_UNUSED == IS_CONST) {
37347
    /* no function found. try a static method in class */
37348
0
    ce = CACHED_PTR(opline->result.num);
37349
0
    if (UNEXPECTED(ce == NULL)) {
37350
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);
37351
0
      if (UNEXPECTED(ce == NULL)) {
37352
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37353
0
        HANDLE_EXCEPTION();
37354
0
      }
37355
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37356
0
        CACHE_PTR(opline->result.num, ce);
37357
0
      }
37358
0
    }
37359
5
  } else if (IS_UNUSED == IS_UNUSED) {
37360
5
    ce = zend_fetch_class(NULL, opline->op1.num);
37361
5
    if (UNEXPECTED(ce == NULL)) {
37362
5
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37363
5
      HANDLE_EXCEPTION();
37364
5
    }
37365
5
  } else {
37366
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
37367
0
  }
37368
37369
0
  if (IS_UNUSED == IS_CONST &&
37370
0
      (IS_TMP_VAR|IS_VAR) == IS_CONST &&
37371
0
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
37372
    /* nothing to do */
37373
0
  } else if (IS_UNUSED != IS_CONST &&
37374
0
             (IS_TMP_VAR|IS_VAR) == IS_CONST &&
37375
0
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
37376
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37377
0
  } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
37378
0
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37379
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37380
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37381
0
        do {
37382
0
          if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
37383
0
            function_name = Z_REFVAL_P(function_name);
37384
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37385
0
              break;
37386
0
            }
37387
0
          } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37388
0
            ZVAL_UNDEFINED_OP2();
37389
0
            if (UNEXPECTED(EG(exception) != NULL)) {
37390
0
              HANDLE_EXCEPTION();
37391
0
            }
37392
0
          }
37393
0
          zend_throw_error(NULL, "Method name must be a string");
37394
0
          zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37395
0
          HANDLE_EXCEPTION();
37396
0
        } while (0);
37397
0
      }
37398
0
    }
37399
37400
0
    if (ce->get_static_method) {
37401
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
37402
0
    } else {
37403
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));
37404
0
    }
37405
0
    if (UNEXPECTED(fbc == NULL)) {
37406
0
      if (EXPECTED(!EG(exception))) {
37407
0
        zend_undefined_method(ce, Z_STR_P(function_name));
37408
0
      }
37409
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37410
0
      HANDLE_EXCEPTION();
37411
0
    }
37412
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37413
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37414
0
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
37415
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
37416
0
    }
37417
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37418
0
      init_func_run_time_cache(&fbc->op_array);
37419
0
    }
37420
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37421
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37422
0
    }
37423
0
  } else {
37424
0
    if (UNEXPECTED(ce->constructor == NULL)) {
37425
0
      zend_throw_error(NULL, "Cannot call constructor");
37426
0
      HANDLE_EXCEPTION();
37427
0
    }
37428
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)) {
37429
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
37430
0
      HANDLE_EXCEPTION();
37431
0
    }
37432
0
    fbc = ce->constructor;
37433
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37434
0
      init_func_run_time_cache(&fbc->op_array);
37435
0
    }
37436
0
  }
37437
37438
0
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
37439
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
37440
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
37441
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37442
0
    } else {
37443
0
      zend_non_static_method_call(fbc);
37444
0
      HANDLE_EXCEPTION();
37445
0
    }
37446
0
  } else {
37447
    /* previous opcode is ZEND_FETCH_CLASS */
37448
0
    if (IS_UNUSED == IS_UNUSED
37449
0
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
37450
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
37451
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
37452
0
        ce = Z_OBJCE(EX(This));
37453
0
      } else {
37454
0
        ce = Z_CE(EX(This));
37455
0
      }
37456
0
    }
37457
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
37458
0
  }
37459
37460
0
  call = zend_vm_stack_push_call_frame(call_info,
37461
0
    fbc, opline->extended_value, ce);
37462
0
  call->prev_execute_data = EX(call);
37463
0
  EX(call) = call;
37464
37465
0
  ZEND_VM_NEXT_OPCODE();
37466
0
}
37467
37468
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37469
0
{
37470
0
  zval *array;
37471
0
  uint32_t size;
37472
0
  USE_OPLINE
37473
37474
0
  SAVE_OPLINE();
37475
0
  array = EX_VAR(opline->result.var);
37476
0
  if (IS_UNUSED != IS_UNUSED) {
37477
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
37478
0
    ZVAL_ARR(array, zend_new_array(size));
37479
    /* Explicitly initialize array as not-packed if flag is set */
37480
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
37481
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
37482
0
    }
37483
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37484
0
  } else {
37485
0
    ZVAL_ARR(array, zend_new_array(0));
37486
0
    ZEND_VM_NEXT_OPCODE();
37487
0
  }
37488
0
}
37489
37490
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37491
0
{
37492
0
  USE_OPLINE
37493
0
  zval *container;
37494
0
  zval *offset;
37495
0
  zend_string *name, *tmp_name;
37496
37497
0
  SAVE_OPLINE();
37498
0
  container = &EX(This);
37499
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37500
37501
0
  do {
37502
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
37503
0
      if (Z_ISREF_P(container)) {
37504
0
        container = Z_REFVAL_P(container);
37505
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
37506
0
          if (IS_UNUSED == IS_CV
37507
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
37508
0
            ZVAL_UNDEFINED_OP1();
37509
0
          }
37510
0
          break;
37511
0
        }
37512
0
      } else {
37513
0
        break;
37514
0
      }
37515
0
    }
37516
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37517
0
      name = Z_STR_P(offset);
37518
0
    } else {
37519
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
37520
0
      if (UNEXPECTED(!name)) {
37521
0
        break;
37522
0
      }
37523
0
    }
37524
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));
37525
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37526
0
      zend_tmp_string_release(tmp_name);
37527
0
    }
37528
0
  } while (0);
37529
37530
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37531
37532
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37533
0
}
37534
37535
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37536
0
{
37537
0
  USE_OPLINE
37538
0
  zval *container;
37539
0
  int result;
37540
0
  zval *offset;
37541
0
  zend_string *name, *tmp_name;
37542
37543
0
  SAVE_OPLINE();
37544
0
  container = &EX(This);
37545
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37546
37547
0
  if (IS_UNUSED == IS_CONST ||
37548
0
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
37549
0
    if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
37550
0
      container = Z_REFVAL_P(container);
37551
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
37552
0
        result = (opline->extended_value & ZEND_ISEMPTY);
37553
0
        goto isset_object_finish;
37554
0
      }
37555
0
    } else {
37556
0
      result = (opline->extended_value & ZEND_ISEMPTY);
37557
0
      goto isset_object_finish;
37558
0
    }
37559
0
  }
37560
37561
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37562
0
    name = Z_STR_P(offset);
37563
0
  } else {
37564
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
37565
0
    if (UNEXPECTED(!name)) {
37566
0
      result = 0;
37567
0
      goto isset_object_finish;
37568
0
    }
37569
0
  }
37570
37571
0
  result =
37572
0
    (opline->extended_value & ZEND_ISEMPTY) ^
37573
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));
37574
37575
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37576
0
    zend_tmp_string_release(tmp_name);
37577
0
  }
37578
37579
0
isset_object_finish:
37580
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37581
37582
0
  ZEND_VM_SMART_BRANCH(result, 1);
37583
0
}
37584
37585
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37586
0
{
37587
0
  USE_OPLINE
37588
37589
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
37590
37591
0
  SAVE_OPLINE();
37592
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
37593
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37594
0
  }
37595
37596
  /* Destroy the previously yielded value */
37597
0
  zval_ptr_dtor(&generator->value);
37598
37599
  /* Destroy the previously yielded key */
37600
0
  zval_ptr_dtor(&generator->key);
37601
37602
  /* Set the new yielded value */
37603
0
  if (IS_UNUSED != IS_UNUSED) {
37604
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37605
      /* Constants and temporary variables aren't yieldable by reference,
37606
       * but we still allow them with a notice. */
37607
0
      if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
37608
0
        zval *value;
37609
37610
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37611
37612
0
        value = NULL;
37613
0
        ZVAL_COPY_VALUE(&generator->value, value);
37614
0
        if (IS_UNUSED == IS_CONST) {
37615
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37616
0
            Z_ADDREF(generator->value);
37617
0
          }
37618
0
        }
37619
0
      } else {
37620
0
        zval *value_ptr = NULL;
37621
37622
        /* If a function call result is yielded and the function did
37623
         * not return by reference we throw a notice. */
37624
0
        do {
37625
0
          if (IS_UNUSED == IS_VAR) {
37626
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
37627
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
37628
0
             && !Z_ISREF_P(value_ptr)) {
37629
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37630
0
              ZVAL_COPY(&generator->value, value_ptr);
37631
0
              break;
37632
0
            }
37633
0
          }
37634
0
          if (Z_ISREF_P(value_ptr)) {
37635
0
            Z_ADDREF_P(value_ptr);
37636
0
          } else {
37637
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
37638
0
          }
37639
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
37640
0
        } while (0);
37641
37642
0
      }
37643
0
    } else {
37644
0
      zval *value = NULL;
37645
37646
      /* Consts, temporary variables and references need copying */
37647
0
      if (IS_UNUSED == IS_CONST) {
37648
0
        ZVAL_COPY_VALUE(&generator->value, value);
37649
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37650
0
          Z_ADDREF(generator->value);
37651
0
        }
37652
0
      } else if (IS_UNUSED == IS_TMP_VAR) {
37653
0
        ZVAL_COPY_VALUE(&generator->value, value);
37654
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
37655
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
37656
37657
0
      } else {
37658
0
        ZVAL_COPY_VALUE(&generator->value, value);
37659
0
        if (IS_UNUSED == IS_CV) {
37660
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
37661
0
        }
37662
0
      }
37663
0
    }
37664
0
  } else {
37665
    /* If no value was specified yield null */
37666
0
    ZVAL_NULL(&generator->value);
37667
0
  }
37668
37669
  /* Set the new yielded key */
37670
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
37671
0
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37672
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
37673
0
      key = Z_REFVAL_P(key);
37674
0
    }
37675
0
    ZVAL_COPY(&generator->key, key);
37676
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37677
37678
0
    if (Z_TYPE(generator->key) == IS_LONG
37679
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
37680
0
    ) {
37681
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
37682
0
    }
37683
0
  } else {
37684
    /* If no key was specified we use auto-increment keys */
37685
0
    generator->largest_used_integer_key++;
37686
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
37687
0
  }
37688
37689
0
  if (RETURN_VALUE_USED(opline)) {
37690
    /* If the return value of yield is used set the send
37691
     * target and initialize it to NULL */
37692
0
    generator->send_target = EX_VAR(opline->result.var);
37693
0
    ZVAL_NULL(generator->send_target);
37694
0
  } else {
37695
0
    generator->send_target = NULL;
37696
0
  }
37697
37698
  /* The GOTO VM uses a local opline variable. We need to set the opline
37699
   * variable in execute_data so we don't resume at an old position. */
37700
0
  SAVE_OPLINE();
37701
37702
0
  ZEND_VM_RETURN();
37703
0
}
37704
37705
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37706
0
{
37707
0
  zval *class_name;
37708
0
  USE_OPLINE
37709
37710
0
  SAVE_OPLINE();
37711
0
  if (IS_UNUSED == IS_UNUSED) {
37712
0
    Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
37713
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37714
0
  } else if (IS_UNUSED == IS_CONST) {
37715
0
    zend_class_entry *ce = CACHED_PTR(opline->extended_value);
37716
37717
0
    if (UNEXPECTED(ce == NULL)) {
37718
0
      class_name = NULL;
37719
0
      ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
37720
0
      CACHE_PTR(opline->extended_value, ce);
37721
0
    }
37722
0
    Z_CE_P(EX_VAR(opline->result.var)) = ce;
37723
0
  } else {
37724
0
    class_name = NULL;
37725
0
try_class_name:
37726
0
    if (Z_TYPE_P(class_name) == IS_OBJECT) {
37727
0
      Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
37728
0
    } else if (Z_TYPE_P(class_name) == IS_STRING) {
37729
0
      Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
37730
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
37731
0
      class_name = Z_REFVAL_P(class_name);
37732
0
      goto try_class_name;
37733
0
    } else {
37734
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
37735
0
        ZVAL_UNDEFINED_OP2();
37736
0
        if (UNEXPECTED(EG(exception) != NULL)) {
37737
0
          HANDLE_EXCEPTION();
37738
0
        }
37739
0
      }
37740
0
      zend_throw_error(NULL, "Class name must be a valid object or a string");
37741
0
    }
37742
0
  }
37743
37744
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37745
0
}
37746
37747
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37748
80
{
37749
80
  USE_OPLINE
37750
80
  zval *function_name;
37751
80
  zend_class_entry *ce;
37752
80
  uint32_t call_info;
37753
80
  zend_function *fbc;
37754
80
  zend_execute_data *call;
37755
37756
80
  SAVE_OPLINE();
37757
37758
80
  if (IS_UNUSED == IS_CONST) {
37759
    /* no function found. try a static method in class */
37760
0
    ce = CACHED_PTR(opline->result.num);
37761
0
    if (UNEXPECTED(ce == NULL)) {
37762
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);
37763
0
      if (UNEXPECTED(ce == NULL)) {
37764
37765
0
        HANDLE_EXCEPTION();
37766
0
      }
37767
0
      if (IS_UNUSED != IS_CONST) {
37768
0
        CACHE_PTR(opline->result.num, ce);
37769
0
      }
37770
0
    }
37771
80
  } else if (IS_UNUSED == IS_UNUSED) {
37772
80
    ce = zend_fetch_class(NULL, opline->op1.num);
37773
80
    if (UNEXPECTED(ce == NULL)) {
37774
37775
0
      HANDLE_EXCEPTION();
37776
0
    }
37777
80
  } else {
37778
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
37779
0
  }
37780
37781
80
  if (IS_UNUSED == IS_CONST &&
37782
80
      IS_UNUSED == IS_CONST &&
37783
80
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
37784
    /* nothing to do */
37785
80
  } else if (IS_UNUSED != IS_CONST &&
37786
80
             IS_UNUSED == IS_CONST &&
37787
80
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
37788
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37789
80
  } else if (IS_UNUSED != IS_UNUSED) {
37790
0
    function_name = NULL;
37791
0
    if (IS_UNUSED != IS_CONST) {
37792
0
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37793
0
        do {
37794
0
          if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
37795
0
            function_name = Z_REFVAL_P(function_name);
37796
0
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37797
0
              break;
37798
0
            }
37799
0
          } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37800
0
            ZVAL_UNDEFINED_OP2();
37801
0
            if (UNEXPECTED(EG(exception) != NULL)) {
37802
0
              HANDLE_EXCEPTION();
37803
0
            }
37804
0
          }
37805
0
          zend_throw_error(NULL, "Method name must be a string");
37806
37807
0
          HANDLE_EXCEPTION();
37808
0
        } while (0);
37809
0
      }
37810
0
    }
37811
37812
0
    if (ce->get_static_method) {
37813
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
37814
0
    } else {
37815
0
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
37816
0
    }
37817
0
    if (UNEXPECTED(fbc == NULL)) {
37818
0
      if (EXPECTED(!EG(exception))) {
37819
0
        zend_undefined_method(ce, Z_STR_P(function_name));
37820
0
      }
37821
37822
0
      HANDLE_EXCEPTION();
37823
0
    }
37824
0
    if (IS_UNUSED == IS_CONST &&
37825
0
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37826
0
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
37827
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
37828
0
    }
37829
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37830
0
      init_func_run_time_cache(&fbc->op_array);
37831
0
    }
37832
0
    if (IS_UNUSED != IS_CONST) {
37833
37834
0
    }
37835
80
  } else {
37836
80
    if (UNEXPECTED(ce->constructor == NULL)) {
37837
5
      zend_throw_error(NULL, "Cannot call constructor");
37838
5
      HANDLE_EXCEPTION();
37839
5
    }
37840
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)) {
37841
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
37842
0
      HANDLE_EXCEPTION();
37843
0
    }
37844
75
    fbc = ce->constructor;
37845
75
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37846
29
      init_func_run_time_cache(&fbc->op_array);
37847
29
    }
37848
75
  }
37849
37850
75
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
37851
75
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
37852
75
      ce = (zend_class_entry*)Z_OBJ(EX(This));
37853
75
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37854
75
    } else {
37855
0
      zend_non_static_method_call(fbc);
37856
0
      HANDLE_EXCEPTION();
37857
0
    }
37858
75
  } else {
37859
    /* previous opcode is ZEND_FETCH_CLASS */
37860
0
    if (IS_UNUSED == IS_UNUSED
37861
0
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
37862
0
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
37863
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
37864
0
        ce = Z_OBJCE(EX(This));
37865
0
      } else {
37866
0
        ce = Z_CE(EX(This));
37867
0
      }
37868
0
    }
37869
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
37870
0
  }
37871
37872
75
  call = zend_vm_stack_push_call_frame(call_info,
37873
75
    fbc, opline->extended_value, ce);
37874
75
  call->prev_execute_data = EX(call);
37875
75
  EX(call) = call;
37876
37877
75
  ZEND_VM_NEXT_OPCODE();
37878
75
}
37879
37880
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37881
90
{
37882
90
  if (IS_UNUSED == IS_UNUSED) {
37883
90
    SAVE_OPLINE();
37884
90
    zend_verify_missing_return_type(EX(func));
37885
90
    HANDLE_EXCEPTION();
37886
90
  } else {
37887
/* prevents "undefined variable opline" errors */
37888
#if 0 || (IS_UNUSED != IS_UNUSED)
37889
    USE_OPLINE
37890
    zval *retval_ref, *retval_ptr;
37891
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
37892
    retval_ref = retval_ptr = NULL;
37893
37894
    if (IS_UNUSED == IS_CONST) {
37895
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
37896
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
37897
    } else if (IS_UNUSED == IS_VAR) {
37898
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
37899
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
37900
      }
37901
      ZVAL_DEREF(retval_ptr);
37902
    } else if (IS_UNUSED == IS_CV) {
37903
      ZVAL_DEREF(retval_ptr);
37904
    }
37905
37906
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
37907
      ZEND_VM_NEXT_OPCODE();
37908
    }
37909
37910
    if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
37911
      SAVE_OPLINE();
37912
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
37913
      if (UNEXPECTED(EG(exception))) {
37914
        HANDLE_EXCEPTION();
37915
      }
37916
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
37917
        ZEND_VM_NEXT_OPCODE();
37918
      }
37919
    }
37920
37921
    zend_reference *ref = NULL;
37922
    if (UNEXPECTED(retval_ref != retval_ptr)) {
37923
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37924
        ref = Z_REF_P(retval_ref);
37925
      } else {
37926
        /* A cast might happen - unwrap the reference if this is a by-value return */
37927
        if (Z_REFCOUNT_P(retval_ref) == 1) {
37928
          ZVAL_UNREF(retval_ref);
37929
        } else {
37930
          Z_DELREF_P(retval_ref);
37931
          ZVAL_COPY(retval_ref, retval_ptr);
37932
        }
37933
        retval_ptr = retval_ref;
37934
      }
37935
    }
37936
37937
    SAVE_OPLINE();
37938
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
37939
      zend_verify_return_error(EX(func), retval_ptr);
37940
      HANDLE_EXCEPTION();
37941
    }
37942
    ZEND_VM_NEXT_OPCODE();
37943
#endif
37944
0
  }
37945
90
}
37946
37947
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37948
19
{
37949
19
  SAVE_OPLINE();
37950
19
  zend_verify_never_error(EX(func));
37951
19
  HANDLE_EXCEPTION();
37952
19
}
37953
37954
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37955
0
{
37956
0
  USE_OPLINE
37957
0
  uint32_t arg_num;
37958
37959
0
  if (IS_UNUSED == IS_CONST) {
37960
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
37961
0
    arg_num = zend_get_arg_offset_by_name(
37962
0
      EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
37963
0
    if (UNEXPECTED(arg_num == 0)) {
37964
      /* Treat this as a by-value argument, and throw an error during SEND. */
37965
0
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37966
0
      ZEND_VM_NEXT_OPCODE();
37967
0
    }
37968
0
  } else {
37969
0
    arg_num = opline->op2.num;
37970
0
  }
37971
37972
0
  if (EXPECTED(0)) {
37973
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37974
0
      ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37975
0
    } else {
37976
0
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37977
0
    }
37978
0
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37979
0
    ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37980
0
  } else {
37981
0
    ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37982
0
  }
37983
0
  ZEND_VM_NEXT_OPCODE();
37984
0
}
37985
37986
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37987
1.40k
{
37988
1.40k
  USE_OPLINE
37989
1.40k
  uint32_t arg_num;
37990
37991
1.40k
  if (IS_UNUSED == IS_CONST) {
37992
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
37993
0
    arg_num = zend_get_arg_offset_by_name(
37994
0
      EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
37995
0
    if (UNEXPECTED(arg_num == 0)) {
37996
      /* Treat this as a by-value argument, and throw an error during SEND. */
37997
0
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37998
0
      ZEND_VM_NEXT_OPCODE();
37999
0
    }
38000
1.40k
  } else {
38001
1.40k
    arg_num = opline->op2.num;
38002
1.40k
  }
38003
38004
1.40k
  if (EXPECTED(1)) {
38005
1.40k
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
38006
73
      ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
38007
1.33k
    } else {
38008
1.33k
      ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
38009
1.33k
    }
38010
1.40k
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
38011
0
    ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
38012
0
  } else {
38013
0
    ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
38014
0
  }
38015
1.40k
  ZEND_VM_NEXT_OPCODE();
38016
1.40k
}
38017
38018
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38019
3.54k
{
38020
3.54k
  USE_OPLINE
38021
38022
3.54k
  zend_execute_data *call = execute_data->call;
38023
3.54k
  if (EXPECTED(!(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF))) {
38024
2.86k
    ZEND_VM_NEXT_OPCODE();
38025
2.86k
  }
38026
38027
3.54k
  SAVE_OPLINE();
38028
675
  zend_handle_undef_args(call);
38029
675
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38030
675
}
38031
38032
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38033
371
{
38034
371
  USE_OPLINE
38035
371
  zval *result;
38036
371
  zend_function *constructor;
38037
371
  zend_class_entry *ce;
38038
371
  zend_execute_data *call;
38039
38040
371
  SAVE_OPLINE();
38041
371
  if (IS_UNUSED == IS_CONST) {
38042
0
    ce = CACHED_PTR(opline->op2.num);
38043
0
    if (UNEXPECTED(ce == NULL)) {
38044
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);
38045
0
      if (UNEXPECTED(ce == NULL)) {
38046
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38047
0
        HANDLE_EXCEPTION();
38048
0
      }
38049
0
      CACHE_PTR(opline->op2.num, ce);
38050
0
    }
38051
371
  } else if (IS_UNUSED == IS_UNUSED) {
38052
371
    ce = zend_fetch_class(NULL, opline->op1.num);
38053
371
    if (UNEXPECTED(ce == NULL)) {
38054
8
      ZVAL_UNDEF(EX_VAR(opline->result.var));
38055
8
      HANDLE_EXCEPTION();
38056
8
    }
38057
371
  } else {
38058
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
38059
0
  }
38060
38061
363
  result = EX_VAR(opline->result.var);
38062
363
  if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
38063
0
    ZVAL_UNDEF(result);
38064
0
    HANDLE_EXCEPTION();
38065
0
  }
38066
38067
363
  constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
38068
363
  if (constructor == NULL) {
38069
    /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
38070
     * opcode is DO_FCALL in case EXT instructions are used. */
38071
330
    if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
38072
330
      ZEND_VM_NEXT_OPCODE_EX(1, 2);
38073
330
    }
38074
38075
0
    if (UNEXPECTED(EG(exception))) {
38076
0
      HANDLE_EXCEPTION();
38077
0
    }
38078
38079
    /* Perform a dummy function call */
38080
0
    call = zend_vm_stack_push_call_frame(
38081
0
      ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
38082
0
      opline->extended_value, NULL);
38083
33
  } else {
38084
33
    if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
38085
17
      init_func_run_time_cache(&constructor->op_array);
38086
17
    }
38087
    /* We are not handling overloaded classes right now */
38088
33
    call = zend_vm_stack_push_call_frame(
38089
33
      ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
38090
33
      constructor,
38091
33
      opline->extended_value,
38092
33
      Z_OBJ_P(result));
38093
33
    Z_ADDREF_P(result);
38094
33
  }
38095
38096
33
  call->prev_execute_data = EX(call);
38097
33
  EX(call) = call;
38098
33
  ZEND_VM_NEXT_OPCODE();
38099
33
}
38100
38101
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38102
179
{
38103
179
  zval *array;
38104
179
  uint32_t size;
38105
179
  USE_OPLINE
38106
38107
179
  SAVE_OPLINE();
38108
179
  array = EX_VAR(opline->result.var);
38109
179
  if (IS_UNUSED != IS_UNUSED) {
38110
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
38111
0
    ZVAL_ARR(array, zend_new_array(size));
38112
    /* Explicitly initialize array as not-packed if flag is set */
38113
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
38114
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
38115
0
    }
38116
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38117
179
  } else {
38118
179
    ZVAL_ARR(array, zend_new_array(0));
38119
179
    ZEND_VM_NEXT_OPCODE();
38120
179
  }
38121
179
}
38122
38123
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38124
738
{
38125
738
  USE_OPLINE
38126
38127
738
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
38128
38129
738
  SAVE_OPLINE();
38130
738
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
38131
5
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38132
5
  }
38133
38134
  /* Destroy the previously yielded value */
38135
733
  zval_ptr_dtor(&generator->value);
38136
38137
  /* Destroy the previously yielded key */
38138
733
  zval_ptr_dtor(&generator->key);
38139
38140
  /* Set the new yielded value */
38141
733
  if (IS_UNUSED != IS_UNUSED) {
38142
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
38143
      /* Constants and temporary variables aren't yieldable by reference,
38144
       * but we still allow them with a notice. */
38145
0
      if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
38146
0
        zval *value;
38147
38148
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38149
38150
0
        value = NULL;
38151
0
        ZVAL_COPY_VALUE(&generator->value, value);
38152
0
        if (IS_UNUSED == IS_CONST) {
38153
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
38154
0
            Z_ADDREF(generator->value);
38155
0
          }
38156
0
        }
38157
0
      } else {
38158
0
        zval *value_ptr = NULL;
38159
38160
        /* If a function call result is yielded and the function did
38161
         * not return by reference we throw a notice. */
38162
0
        do {
38163
0
          if (IS_UNUSED == IS_VAR) {
38164
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
38165
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
38166
0
             && !Z_ISREF_P(value_ptr)) {
38167
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38168
0
              ZVAL_COPY(&generator->value, value_ptr);
38169
0
              break;
38170
0
            }
38171
0
          }
38172
0
          if (Z_ISREF_P(value_ptr)) {
38173
0
            Z_ADDREF_P(value_ptr);
38174
0
          } else {
38175
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
38176
0
          }
38177
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
38178
0
        } while (0);
38179
38180
0
      }
38181
0
    } else {
38182
0
      zval *value = NULL;
38183
38184
      /* Consts, temporary variables and references need copying */
38185
0
      if (IS_UNUSED == IS_CONST) {
38186
0
        ZVAL_COPY_VALUE(&generator->value, value);
38187
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
38188
0
          Z_ADDREF(generator->value);
38189
0
        }
38190
0
      } else if (IS_UNUSED == IS_TMP_VAR) {
38191
0
        ZVAL_COPY_VALUE(&generator->value, value);
38192
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
38193
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
38194
38195
0
      } else {
38196
0
        ZVAL_COPY_VALUE(&generator->value, value);
38197
0
        if (IS_UNUSED == IS_CV) {
38198
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
38199
0
        }
38200
0
      }
38201
0
    }
38202
733
  } else {
38203
    /* If no value was specified yield null */
38204
733
    ZVAL_NULL(&generator->value);
38205
733
  }
38206
38207
  /* Set the new yielded key */
38208
733
  if (IS_UNUSED != IS_UNUSED) {
38209
0
    zval *key = NULL;
38210
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
38211
0
      key = Z_REFVAL_P(key);
38212
0
    }
38213
0
    ZVAL_COPY(&generator->key, key);
38214
38215
0
    if (Z_TYPE(generator->key) == IS_LONG
38216
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
38217
0
    ) {
38218
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
38219
0
    }
38220
733
  } else {
38221
    /* If no key was specified we use auto-increment keys */
38222
733
    generator->largest_used_integer_key++;
38223
733
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
38224
733
  }
38225
38226
733
  if (RETURN_VALUE_USED(opline)) {
38227
    /* If the return value of yield is used set the send
38228
     * target and initialize it to NULL */
38229
260
    generator->send_target = EX_VAR(opline->result.var);
38230
260
    ZVAL_NULL(generator->send_target);
38231
473
  } else {
38232
473
    generator->send_target = NULL;
38233
473
  }
38234
38235
  /* The GOTO VM uses a local opline variable. We need to set the opline
38236
   * variable in execute_data so we don't resume at an old position. */
38237
733
  SAVE_OPLINE();
38238
38239
733
  ZEND_VM_RETURN();
38240
733
}
38241
38242
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38243
9.08k
{
38244
9.08k
  USE_OPLINE
38245
38246
9.08k
  if (EXPECTED(Z_TYPE(EX(This)) == IS_OBJECT)) {
38247
8.96k
    zval *result = EX_VAR(opline->result.var);
38248
38249
8.96k
    ZVAL_OBJ(result, Z_OBJ(EX(This)));
38250
8.96k
    Z_ADDREF_P(result);
38251
8.96k
    ZEND_VM_NEXT_OPCODE();
38252
8.96k
  } else {
38253
122
    ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38254
122
  }
38255
9.08k
}
38256
38257
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38258
1.72k
{
38259
1.72k
  USE_OPLINE
38260
38261
  /* For symbol tables we need to deal with exactly the same problems as for property tables. */
38262
1.72k
  ZVAL_ARR(EX_VAR(opline->result.var),
38263
1.72k
    zend_proptable_to_symtable(&EG(symbol_table), /* always_duplicate */ 1));
38264
1.72k
  ZEND_VM_NEXT_OPCODE();
38265
1.72k
}
38266
38267
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38268
226
{
38269
226
  USE_OPLINE
38270
38271
226
  ZVAL_BOOL(EX_VAR(opline->result.var),
38272
226
    (opline->extended_value & ZEND_ISEMPTY) ^
38273
226
     (Z_TYPE(EX(This)) == IS_OBJECT));
38274
226
  ZEND_VM_NEXT_OPCODE();
38275
226
}
38276
38277
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38278
15
{
38279
15
  USE_OPLINE
38280
38281
15
  if (IS_UNUSED == IS_UNUSED) {
38282
15
    SAVE_OPLINE();
38283
15
    if (UNEXPECTED(!EX(func)->common.scope)) {
38284
0
      zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
38285
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
38286
0
      HANDLE_EXCEPTION();
38287
15
    } else {
38288
15
      zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
38289
15
      ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
38290
15
      if (UNEXPECTED(EG(exception))) {
38291
0
        HANDLE_EXCEPTION();
38292
0
      }
38293
15
      ZEND_VM_NEXT_OPCODE();
38294
15
    }
38295
15
  } else {
38296
0
    zval *op1;
38297
38298
0
    SAVE_OPLINE();
38299
0
    op1 = NULL;
38300
0
    while (1) {
38301
0
      if (Z_TYPE_P(op1) == IS_OBJECT) {
38302
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
38303
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
38304
0
        op1 = Z_REFVAL_P(op1);
38305
0
        continue;
38306
0
      } else {
38307
0
        if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
38308
0
          ZVAL_UNDEFINED_OP1();
38309
0
        }
38310
0
        zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
38311
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38312
0
      }
38313
0
      break;
38314
0
    }
38315
38316
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38317
0
  }
38318
15
}
38319
38320
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38321
352
{
38322
352
  USE_OPLINE
38323
38324
352
  if (Z_TYPE(EX(This)) == IS_OBJECT) {
38325
43
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
38326
309
  } else if (Z_CE(EX(This))) {
38327
304
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
38328
304
  } else {
38329
5
    ZEND_ASSERT(!EX(func)->common.scope);
38330
5
    SAVE_OPLINE();
38331
5
    zend_throw_error(NULL, "get_called_class() must be called from within a class");
38332
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
38333
5
    HANDLE_EXCEPTION();
38334
5
  }
38335
347
  ZEND_VM_NEXT_OPCODE();
38336
347
}
38337
38338
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38339
107
{
38340
107
  USE_OPLINE
38341
38342
107
  ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
38343
107
  ZEND_VM_NEXT_OPCODE();
38344
107
}
38345
38346
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38347
189
{
38348
189
  USE_OPLINE
38349
189
  zend_array *ht;
38350
189
  uint32_t arg_count, result_size, skip;
38351
38352
189
  arg_count = EX_NUM_ARGS();
38353
189
  if (IS_UNUSED == IS_CONST) {
38354
0
    skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
38355
0
    if (arg_count < skip) {
38356
0
      result_size = 0;
38357
0
    } else {
38358
0
      result_size = arg_count - skip;
38359
0
    }
38360
189
  } else {
38361
189
    skip = 0;
38362
189
    result_size = arg_count;
38363
189
  }
38364
38365
189
  if (result_size) {
38366
166
    SAVE_OPLINE();
38367
166
    uint32_t first_extra_arg = EX(func)->op_array.num_args;
38368
38369
166
    ht = zend_new_array(result_size);
38370
166
    ZVAL_ARR(EX_VAR(opline->result.var), ht);
38371
166
    zend_hash_real_init_packed(ht);
38372
166
    ZEND_HASH_FILL_PACKED(ht) {
38373
166
      zval *p, *q;
38374
166
      uint32_t i = skip;
38375
166
      p = EX_VAR_NUM(i);
38376
166
      if (arg_count > first_extra_arg) {
38377
256
        while (i < first_extra_arg) {
38378
152
          q = p;
38379
152
          if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
38380
117
            ZVAL_DEREF(q);
38381
117
            if (Z_OPT_REFCOUNTED_P(q)) {
38382
0
              Z_ADDREF_P(q);
38383
0
            }
38384
117
            ZEND_HASH_FILL_SET(q);
38385
117
          } else {
38386
35
            ZEND_HASH_FILL_SET_NULL();
38387
35
          }
38388
152
          ZEND_HASH_FILL_NEXT();
38389
152
          p++;
38390
152
          i++;
38391
152
        }
38392
104
        if (skip < first_extra_arg) {
38393
56
          skip = 0;
38394
56
        } else {
38395
48
          skip -= first_extra_arg;
38396
48
        }
38397
104
        p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
38398
104
      }
38399
405
      while (i < arg_count) {
38400
239
        q = p;
38401
239
        if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
38402
239
          ZVAL_DEREF(q);
38403
239
          if (Z_OPT_REFCOUNTED_P(q)) {
38404
0
            Z_ADDREF_P(q);
38405
0
          }
38406
239
          ZEND_HASH_FILL_SET(q);
38407
239
        } else {
38408
0
          ZEND_HASH_FILL_SET_NULL();
38409
0
        }
38410
239
        ZEND_HASH_FILL_NEXT();
38411
239
        p++;
38412
239
        i++;
38413
239
      }
38414
166
    } ZEND_HASH_FILL_END();
38415
166
    ht->nNumOfElements = result_size;
38416
166
  } else {
38417
23
    ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
38418
23
  }
38419
189
  ZEND_VM_NEXT_OPCODE();
38420
189
}
38421
38422
/* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
38423
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38424
513
{
38425
513
  USE_OPLINE
38426
513
  zend_execute_data *call = EX(call);
38427
38428
513
  zend_closure_from_frame(EX_VAR(opline->result.var), call);
38429
38430
513
  if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
38431
149
    OBJ_RELEASE(Z_OBJ(call->This));
38432
149
  }
38433
38434
513
  EX(call) = call->prev_execute_data;
38435
38436
513
  zend_vm_stack_free_call_frame(call);
38437
38438
513
  ZEND_VM_NEXT_OPCODE();
38439
513
}
38440
38441
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38442
0
{
38443
0
  USE_OPLINE
38444
0
  SAVE_OPLINE();
38445
38446
0
  zval *result = EX_VAR(opline->result.var);
38447
0
  ZVAL_NULL(result);
38448
38449
#if 0 || 0
38450
  if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
38451
    zend_frameless_observed_call(execute_data);
38452
  } else
38453
#endif
38454
0
  {
38455
0
    zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
38456
0
    function(EX_VAR(opline->result.var));
38457
0
  }
38458
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38459
0
}
38460
38461
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38462
0
{
38463
0
  USE_OPLINE
38464
0
  SAVE_OPLINE();
38465
38466
0
  zval *result = EX_VAR(opline->result.var);
38467
0
  ZVAL_NULL(result);
38468
38469
0
#if 0 || 1
38470
0
  if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
38471
0
    zend_frameless_observed_call(execute_data);
38472
0
  } else
38473
0
#endif
38474
0
  {
38475
0
    zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
38476
0
    function(EX_VAR(opline->result.var));
38477
0
  }
38478
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38479
0
}
38480
38481
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38482
23
{
38483
23
  USE_OPLINE
38484
23
  zval *object;
38485
23
  zval *property;
38486
23
  zval *value;
38487
23
  zval *zptr;
38488
23
  void *_cache_slot[3] = {0};
38489
23
  void **cache_slot;
38490
23
  zend_property_info *prop_info;
38491
23
  zend_object *zobj;
38492
23
  zend_string *name, *tmp_name;
38493
38494
23
  SAVE_OPLINE();
38495
23
  object = &EX(This);
38496
23
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38497
38498
23
  do {
38499
23
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
38500
38501
23
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38502
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38503
0
        object = Z_REFVAL_P(object);
38504
0
        goto assign_op_object;
38505
0
      }
38506
0
      if (IS_UNUSED == IS_CV
38507
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38508
0
        ZVAL_UNDEFINED_OP1();
38509
0
      }
38510
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38511
0
      break;
38512
0
    }
38513
38514
23
assign_op_object:
38515
    /* here we are sure we are dealing with an object */
38516
23
    zobj = Z_OBJ_P(object);
38517
23
    if (IS_CV == IS_CONST) {
38518
0
      name = Z_STR_P(property);
38519
23
    } else {
38520
23
      name = zval_try_get_tmp_string(property, &tmp_name);
38521
23
      if (UNEXPECTED(!name)) {
38522
0
        UNDEF_RESULT();
38523
0
        break;
38524
0
      }
38525
23
    }
38526
23
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
38527
23
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38528
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38529
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38530
0
          ZVAL_NULL(EX_VAR(opline->result.var));
38531
0
        }
38532
0
      } else {
38533
0
        zend_reference *ref;
38534
38535
0
        do {
38536
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
38537
0
            ref = Z_REF_P(zptr);
38538
0
            zptr = Z_REFVAL_P(zptr);
38539
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
38540
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
38541
0
              break;
38542
0
            }
38543
0
          }
38544
38545
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
38546
0
          if (prop_info) {
38547
            /* special case for typed properties */
38548
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
38549
0
          } else {
38550
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
38551
0
          }
38552
0
        } while (0);
38553
38554
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38555
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
38556
0
        }
38557
0
      }
38558
23
    } else {
38559
23
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
38560
23
    }
38561
23
    if (IS_CV != IS_CONST) {
38562
23
      zend_tmp_string_release(tmp_name);
38563
23
    }
38564
23
  } while (0);
38565
38566
23
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
38567
38568
38569
  /* assign_obj has two opcodes! */
38570
23
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
38571
23
}
38572
38573
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
38574
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38575
0
{
38576
0
  USE_OPLINE
38577
0
  zval *object;
38578
0
  zval *property;
38579
0
  zval *zptr;
38580
0
  void *_cache_slot[3] = {0};
38581
0
  void **cache_slot;
38582
0
  zend_property_info *prop_info;
38583
0
  zend_object *zobj;
38584
0
  zend_string *name, *tmp_name;
38585
38586
0
  SAVE_OPLINE();
38587
0
  object = &EX(This);
38588
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38589
38590
0
  do {
38591
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38592
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38593
0
        object = Z_REFVAL_P(object);
38594
0
        goto pre_incdec_object;
38595
0
      }
38596
0
      if (IS_UNUSED == IS_CV
38597
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38598
0
        ZVAL_UNDEFINED_OP1();
38599
0
      }
38600
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38601
0
      break;
38602
0
    }
38603
38604
0
pre_incdec_object:
38605
    /* here we are sure we are dealing with an object */
38606
0
    zobj = Z_OBJ_P(object);
38607
0
    if (IS_CV == IS_CONST) {
38608
0
      name = Z_STR_P(property);
38609
0
    } else {
38610
0
      name = zval_try_get_tmp_string(property, &tmp_name);
38611
0
      if (UNEXPECTED(!name)) {
38612
0
        UNDEF_RESULT();
38613
0
        break;
38614
0
      }
38615
0
    }
38616
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
38617
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38618
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38619
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38620
0
          ZVAL_NULL(EX_VAR(opline->result.var));
38621
0
        }
38622
0
      } else {
38623
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
38624
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
38625
0
      }
38626
0
    } else {
38627
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
38628
0
    }
38629
0
    if (IS_CV != IS_CONST) {
38630
0
      zend_tmp_string_release(tmp_name);
38631
0
    }
38632
0
  } while (0);
38633
38634
38635
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38636
0
}
38637
38638
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38639
0
{
38640
0
  USE_OPLINE
38641
0
  zval *object;
38642
0
  zval *property;
38643
0
  zval *zptr;
38644
0
  void *_cache_slot[3] = {0};
38645
0
  void **cache_slot;
38646
0
  zend_property_info *prop_info;
38647
0
  zend_object *zobj;
38648
0
  zend_string *name, *tmp_name;
38649
38650
0
  SAVE_OPLINE();
38651
0
  object = &EX(This);
38652
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38653
38654
0
  do {
38655
0
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38656
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38657
0
        object = Z_REFVAL_P(object);
38658
0
        goto post_incdec_object;
38659
0
      }
38660
0
      if (IS_UNUSED == IS_CV
38661
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38662
0
        ZVAL_UNDEFINED_OP1();
38663
0
      }
38664
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38665
0
      break;
38666
0
    }
38667
38668
0
post_incdec_object:
38669
    /* here we are sure we are dealing with an object */
38670
0
    zobj = Z_OBJ_P(object);
38671
0
    if (IS_CV == IS_CONST) {
38672
0
      name = Z_STR_P(property);
38673
0
    } else {
38674
0
      name = zval_try_get_tmp_string(property, &tmp_name);
38675
0
      if (UNEXPECTED(!name)) {
38676
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38677
0
        break;
38678
0
      }
38679
0
    }
38680
0
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
38681
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38682
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38683
0
        ZVAL_NULL(EX_VAR(opline->result.var));
38684
0
      } else {
38685
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
38686
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
38687
0
      }
38688
0
    } else {
38689
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
38690
0
    }
38691
0
    if (IS_CV != IS_CONST) {
38692
0
      zend_tmp_string_release(tmp_name);
38693
0
    }
38694
0
  } while (0);
38695
38696
38697
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38698
0
}
38699
38700
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38701
258
{
38702
258
  USE_OPLINE
38703
258
  zval *container;
38704
258
  void **cache_slot = NULL;
38705
38706
258
  SAVE_OPLINE();
38707
258
  container = &EX(This);
38708
38709
258
  if (IS_UNUSED == IS_CONST ||
38710
258
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38711
0
    do {
38712
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38713
0
        container = Z_REFVAL_P(container);
38714
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
38715
0
          break;
38716
0
        }
38717
0
      }
38718
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
38719
0
        ZVAL_UNDEFINED_OP1();
38720
0
      }
38721
0
      zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38722
0
      ZVAL_NULL(EX_VAR(opline->result.var));
38723
0
      goto fetch_obj_r_finish;
38724
0
    } while (0);
38725
0
  }
38726
38727
  /* here we are sure we are dealing with an object */
38728
258
  do {
38729
258
    zend_object *zobj = Z_OBJ_P(container);
38730
258
    zend_string *name, *tmp_name;
38731
258
    zval *retval;
38732
38733
258
    if (IS_CV == IS_CONST) {
38734
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
38735
38736
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
38737
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38738
38739
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38740
0
fetch_obj_r_simple:
38741
0
          retval = OBJ_PROP(zobj, prop_offset);
38742
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
38743
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38744
0
              goto fetch_obj_r_copy;
38745
0
            } else {
38746
0
fetch_obj_r_fast_copy:
38747
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38748
0
              ZEND_VM_NEXT_OPCODE();
38749
0
            }
38750
0
          }
38751
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
38752
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38753
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
38754
0
            prop_offset = prop_info->offset;
38755
0
            goto fetch_obj_r_simple;
38756
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
38757
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
38758
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
38759
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
38760
38761
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
38762
0
            if (IS_UNUSED & IS_CV) {
38763
0
              GC_ADDREF(zobj);
38764
0
            }
38765
0
            if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
38766
0
              call_info |= ZEND_CALL_RELEASE_THIS;
38767
0
            }
38768
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
38769
0
            call->prev_execute_data = execute_data;
38770
0
            call->call = NULL;
38771
0
            call->return_value = EX_VAR(opline->result.var);
38772
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
38773
38774
0
            execute_data = call;
38775
0
            EG(current_execute_data) = execute_data;
38776
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
38777
38778
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
38779
            opline = hook->op_array.opcodes;
38780
#else
38781
0
            EX(opline) = hook->op_array.opcodes;
38782
0
#endif
38783
0
            LOAD_OPLINE_EX();
38784
38785
38786
0
            ZEND_VM_ENTER_EX();
38787
0
          }
38788
          /* Fall through to read_property for hooks. */
38789
0
        } else if (EXPECTED(zobj->properties != NULL)) {
38790
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
38791
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38792
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
38793
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
38794
38795
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
38796
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
38797
38798
0
              if (EXPECTED(p->key == name) ||
38799
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
38800
0
                   EXPECTED(p->key != NULL) &&
38801
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
38802
0
                retval = &p->val;
38803
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38804
0
                  goto fetch_obj_r_copy;
38805
0
                } else {
38806
0
                  goto fetch_obj_r_fast_copy;
38807
0
                }
38808
0
              }
38809
0
            }
38810
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
38811
0
          }
38812
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
38813
0
          if (EXPECTED(retval)) {
38814
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
38815
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
38816
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38817
0
              goto fetch_obj_r_copy;
38818
0
            } else {
38819
0
              goto fetch_obj_r_fast_copy;
38820
0
            }
38821
0
          }
38822
0
        }
38823
0
      }
38824
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38825
258
    } else {
38826
258
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38827
258
      if (UNEXPECTED(!name)) {
38828
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
38829
0
        break;
38830
0
      }
38831
258
    }
38832
38833
258
#if ZEND_DEBUG
38834
    /* For non-standard object handlers, verify a declared property type in debug builds.
38835
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
38836
258
    zend_property_info *prop_info = NULL;
38837
258
    if (zobj->handlers->read_property != zend_std_read_property) {
38838
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
38839
0
    }
38840
258
#endif
38841
258
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
38842
258
#if ZEND_DEBUG
38843
258
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
38844
258
        && ZEND_TYPE_IS_SET(prop_info->type)) {
38845
0
      ZVAL_OPT_DEREF(retval);
38846
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
38847
0
    }
38848
258
#endif
38849
38850
258
    if (IS_CV != IS_CONST) {
38851
257
      zend_tmp_string_release(tmp_name);
38852
257
    }
38853
38854
258
    if (retval != EX_VAR(opline->result.var)) {
38855
244
fetch_obj_r_copy:
38856
244
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38857
244
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
38858
0
      zend_unwrap_reference(retval);
38859
0
    }
38860
258
  } while (0);
38861
38862
258
fetch_obj_r_finish:
38863
38864
38865
257
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38866
257
}
38867
38868
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38869
27
{
38870
27
  USE_OPLINE
38871
27
  zval *property, *container, *result;
38872
38873
27
  SAVE_OPLINE();
38874
38875
27
  container = &EX(This);
38876
27
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38877
27
  result = EX_VAR(opline->result.var);
38878
27
  zend_fetch_property_address(
38879
27
    result, container, IS_UNUSED, property, IS_CV,
38880
27
    ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
38881
27
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
38882
38883
27
  if (IS_UNUSED == IS_VAR) {
38884
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38885
0
  }
38886
27
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38887
27
}
38888
38889
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38890
0
{
38891
0
  USE_OPLINE
38892
0
  zval *property, *container, *result;
38893
38894
0
  SAVE_OPLINE();
38895
0
  container = &EX(This);
38896
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38897
0
  result = EX_VAR(opline->result.var);
38898
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);
38899
38900
0
  if (IS_UNUSED == IS_VAR) {
38901
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38902
0
  }
38903
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38904
0
}
38905
38906
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38907
20
{
38908
20
  USE_OPLINE
38909
20
  zval *container;
38910
20
  void **cache_slot = NULL;
38911
38912
20
  SAVE_OPLINE();
38913
20
  container = &EX(This);
38914
38915
20
  if (IS_UNUSED == IS_CONST ||
38916
20
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38917
0
    do {
38918
0
      if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38919
0
        container = Z_REFVAL_P(container);
38920
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
38921
0
          break;
38922
0
        }
38923
0
      }
38924
0
      if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
38925
0
        ZVAL_UNDEFINED_OP2();
38926
0
      }
38927
0
      ZVAL_NULL(EX_VAR(opline->result.var));
38928
0
      goto fetch_obj_is_finish;
38929
0
    } while (0);
38930
0
  }
38931
38932
  /* here we are sure we are dealing with an object */
38933
20
  do {
38934
20
    zend_object *zobj = Z_OBJ_P(container);
38935
20
    zend_string *name, *tmp_name;
38936
20
    zval *retval;
38937
38938
20
    if (IS_CV == IS_CONST) {
38939
0
      cache_slot = CACHE_ADDR(opline->extended_value);
38940
38941
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
38942
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38943
38944
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38945
0
fetch_obj_is_simple:
38946
0
          retval = OBJ_PROP(zobj, prop_offset);
38947
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
38948
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38949
0
              goto fetch_obj_is_copy;
38950
0
            } else {
38951
0
fetch_obj_is_fast_copy:
38952
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38953
0
              ZEND_VM_NEXT_OPCODE();
38954
0
            }
38955
0
          }
38956
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
38957
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
38958
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38959
0
            prop_offset = prop_info->offset;
38960
0
            goto fetch_obj_is_simple;
38961
0
          }
38962
          /* Fall through to read_property for hooks. */
38963
0
        } else if (EXPECTED(zobj->properties != NULL)) {
38964
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
38965
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38966
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
38967
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
38968
38969
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
38970
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
38971
38972
0
              if (EXPECTED(p->key == name) ||
38973
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
38974
0
                   EXPECTED(p->key != NULL) &&
38975
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
38976
0
                retval = &p->val;
38977
0
                if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38978
0
                  goto fetch_obj_is_copy;
38979
0
                } else {
38980
0
                  goto fetch_obj_is_fast_copy;
38981
0
                }
38982
0
              }
38983
0
            }
38984
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
38985
0
          }
38986
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
38987
0
          if (EXPECTED(retval)) {
38988
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
38989
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
38990
0
            if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38991
0
              goto fetch_obj_is_copy;
38992
0
            } else {
38993
0
              goto fetch_obj_is_fast_copy;
38994
0
            }
38995
0
          }
38996
0
        }
38997
0
      }
38998
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38999
20
    } else {
39000
20
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39001
20
      if (UNEXPECTED(!name)) {
39002
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
39003
0
        break;
39004
0
      }
39005
20
    }
39006
39007
20
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
39008
39009
20
    if (IS_CV != IS_CONST) {
39010
20
      zend_tmp_string_release(tmp_name);
39011
20
    }
39012
39013
20
    if (retval != EX_VAR(opline->result.var)) {
39014
15
fetch_obj_is_copy:
39015
15
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
39016
15
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
39017
0
      zend_unwrap_reference(retval);
39018
0
    }
39019
20
  } while (0);
39020
39021
20
fetch_obj_is_finish:
39022
39023
39024
20
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39025
20
}
39026
39027
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39028
0
{
39029
#if 0
39030
  USE_OPLINE
39031
#endif
39032
39033
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
39034
    /* Behave like FETCH_OBJ_W */
39035
0
    if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
39036
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39037
0
    }
39038
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39039
0
  } else {
39040
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39041
0
  }
39042
0
}
39043
39044
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39045
0
{
39046
0
  USE_OPLINE
39047
0
  zval *container, *property, *result;
39048
39049
0
  SAVE_OPLINE();
39050
0
  container = &EX(This);
39051
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39052
0
  result = EX_VAR(opline->result.var);
39053
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);
39054
39055
0
  if (IS_UNUSED == IS_VAR) {
39056
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
39057
0
  }
39058
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39059
0
}
39060
39061
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39062
5
{
39063
5
  USE_OPLINE
39064
5
  zval *object, *value, tmp;
39065
5
  zend_object *zobj;
39066
5
  zend_string *name, *tmp_name;
39067
5
  zend_refcounted *garbage = NULL;
39068
39069
5
  SAVE_OPLINE();
39070
5
  object = &EX(This);
39071
5
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
39072
39073
5
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39074
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39075
0
      object = Z_REFVAL_P(object);
39076
0
      goto assign_object;
39077
0
    }
39078
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);
39079
0
    value = &EG(uninitialized_zval);
39080
0
    goto free_and_exit_assign_obj;
39081
0
  }
39082
39083
5
assign_object:
39084
5
  zobj = Z_OBJ_P(object);
39085
5
  if (IS_CV == IS_CONST) {
39086
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39087
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
39088
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39089
0
      zval *property_val;
39090
0
      zend_property_info *prop_info;
39091
39092
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39093
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39094
39095
0
assign_obj_simple:
39096
0
        property_val = OBJ_PROP(zobj, prop_offset);
39097
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
39098
0
          if (prop_info != NULL) {
39099
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39100
0
            goto free_and_exit_assign_obj;
39101
0
          } else {
39102
0
fast_assign_obj:
39103
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
39104
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39105
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
39106
0
            }
39107
0
            goto exit_assign_obj;
39108
0
          }
39109
0
        }
39110
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39111
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39112
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39113
0
          zobj = zend_lazy_object_init(zobj);
39114
0
          if (!zobj) {
39115
0
            value = &EG(uninitialized_zval);
39116
0
            goto free_and_exit_assign_obj;
39117
0
          }
39118
0
        }
39119
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39120
0
          rebuild_object_properties_internal(zobj);
39121
0
        }
39122
0
        if (EXPECTED(zobj->properties != NULL)) {
39123
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39124
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39125
0
              GC_DELREF(zobj->properties);
39126
0
            }
39127
0
            zobj->properties = zend_array_dup(zobj->properties);
39128
0
          }
39129
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
39130
0
          if (property_val) {
39131
0
            goto fast_assign_obj;
39132
0
          }
39133
0
        }
39134
39135
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39136
0
          if (IS_CONST == IS_CONST) {
39137
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39138
0
              Z_ADDREF_P(value);
39139
0
            }
39140
0
          } else if (IS_CONST != IS_TMP_VAR) {
39141
0
            if (Z_ISREF_P(value)) {
39142
0
              if (IS_CONST == IS_VAR) {
39143
0
                zend_reference *ref = Z_REF_P(value);
39144
0
                if (GC_DELREF(ref) == 0) {
39145
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39146
0
                  efree_size(ref, sizeof(zend_reference));
39147
0
                  value = &tmp;
39148
0
                } else {
39149
0
                  value = Z_REFVAL_P(value);
39150
0
                  Z_TRY_ADDREF_P(value);
39151
0
                }
39152
0
              } else {
39153
0
                value = Z_REFVAL_P(value);
39154
0
                Z_TRY_ADDREF_P(value);
39155
0
              }
39156
0
            } else if (IS_CONST == IS_CV) {
39157
0
              Z_TRY_ADDREF_P(value);
39158
0
            }
39159
0
          }
39160
0
          zend_hash_add_new(zobj->properties, name, value);
39161
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39162
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
39163
0
          }
39164
0
          goto exit_assign_obj;
39165
0
        }
39166
0
      } else {
39167
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39168
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39169
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
39170
0
          prop_offset = prop_info->offset;
39171
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39172
0
            prop_info = NULL;
39173
0
          }
39174
0
          goto assign_obj_simple;
39175
0
        }
39176
        /* Fall through to write_property for hooks. */
39177
0
      }
39178
0
    }
39179
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39180
5
  } else {
39181
5
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39182
5
    if (UNEXPECTED(!name)) {
39183
39184
0
      UNDEF_RESULT();
39185
0
      goto exit_assign_obj;
39186
0
    }
39187
5
  }
39188
39189
5
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
39190
0
    ZVAL_DEREF(value);
39191
0
  }
39192
39193
5
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39194
39195
5
  if (IS_CV != IS_CONST) {
39196
5
    zend_tmp_string_release(tmp_name);
39197
5
  }
39198
39199
5
free_and_exit_assign_obj:
39200
5
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39201
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39202
0
  }
39203
39204
5
exit_assign_obj:
39205
5
  if (garbage) {
39206
0
    GC_DTOR_NO_REF(garbage);
39207
0
  }
39208
39209
39210
  /* assign_obj has two opcodes! */
39211
5
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39212
5
}
39213
39214
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39215
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39216
20
{
39217
20
  USE_OPLINE
39218
20
  zval *object, *value, tmp;
39219
20
  zend_object *zobj;
39220
20
  zend_string *name, *tmp_name;
39221
20
  zend_refcounted *garbage = NULL;
39222
39223
20
  SAVE_OPLINE();
39224
20
  object = &EX(This);
39225
20
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
39226
39227
20
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39228
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39229
0
      object = Z_REFVAL_P(object);
39230
0
      goto assign_object;
39231
0
    }
39232
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);
39233
0
    value = &EG(uninitialized_zval);
39234
0
    goto free_and_exit_assign_obj;
39235
0
  }
39236
39237
20
assign_object:
39238
20
  zobj = Z_OBJ_P(object);
39239
20
  if (IS_CV == IS_CONST) {
39240
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39241
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
39242
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39243
0
      zval *property_val;
39244
0
      zend_property_info *prop_info;
39245
39246
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39247
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39248
39249
0
assign_obj_simple:
39250
0
        property_val = OBJ_PROP(zobj, prop_offset);
39251
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
39252
0
          if (prop_info != NULL) {
39253
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39254
0
            goto free_and_exit_assign_obj;
39255
0
          } else {
39256
0
fast_assign_obj:
39257
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
39258
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39259
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
39260
0
            }
39261
0
            goto exit_assign_obj;
39262
0
          }
39263
0
        }
39264
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39265
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39266
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39267
0
          zobj = zend_lazy_object_init(zobj);
39268
0
          if (!zobj) {
39269
0
            value = &EG(uninitialized_zval);
39270
0
            goto free_and_exit_assign_obj;
39271
0
          }
39272
0
        }
39273
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39274
0
          rebuild_object_properties_internal(zobj);
39275
0
        }
39276
0
        if (EXPECTED(zobj->properties != NULL)) {
39277
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39278
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39279
0
              GC_DELREF(zobj->properties);
39280
0
            }
39281
0
            zobj->properties = zend_array_dup(zobj->properties);
39282
0
          }
39283
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
39284
0
          if (property_val) {
39285
0
            goto fast_assign_obj;
39286
0
          }
39287
0
        }
39288
39289
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39290
0
          if (IS_TMP_VAR == IS_CONST) {
39291
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39292
0
              Z_ADDREF_P(value);
39293
0
            }
39294
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
39295
0
            if (Z_ISREF_P(value)) {
39296
0
              if (IS_TMP_VAR == IS_VAR) {
39297
0
                zend_reference *ref = Z_REF_P(value);
39298
0
                if (GC_DELREF(ref) == 0) {
39299
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39300
0
                  efree_size(ref, sizeof(zend_reference));
39301
0
                  value = &tmp;
39302
0
                } else {
39303
0
                  value = Z_REFVAL_P(value);
39304
0
                  Z_TRY_ADDREF_P(value);
39305
0
                }
39306
0
              } else {
39307
0
                value = Z_REFVAL_P(value);
39308
0
                Z_TRY_ADDREF_P(value);
39309
0
              }
39310
0
            } else if (IS_TMP_VAR == IS_CV) {
39311
0
              Z_TRY_ADDREF_P(value);
39312
0
            }
39313
0
          }
39314
0
          zend_hash_add_new(zobj->properties, name, value);
39315
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39316
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
39317
0
          }
39318
0
          goto exit_assign_obj;
39319
0
        }
39320
0
      } else {
39321
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39322
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39323
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
39324
0
          prop_offset = prop_info->offset;
39325
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39326
0
            prop_info = NULL;
39327
0
          }
39328
0
          goto assign_obj_simple;
39329
0
        }
39330
        /* Fall through to write_property for hooks. */
39331
0
      }
39332
0
    }
39333
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39334
20
  } else {
39335
20
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39336
20
    if (UNEXPECTED(!name)) {
39337
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39338
0
      UNDEF_RESULT();
39339
0
      goto exit_assign_obj;
39340
0
    }
39341
20
  }
39342
39343
20
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
39344
0
    ZVAL_DEREF(value);
39345
0
  }
39346
39347
20
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39348
39349
20
  if (IS_CV != IS_CONST) {
39350
20
    zend_tmp_string_release(tmp_name);
39351
20
  }
39352
39353
20
free_and_exit_assign_obj:
39354
20
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39355
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39356
0
  }
39357
20
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39358
20
exit_assign_obj:
39359
20
  if (garbage) {
39360
0
    GC_DTOR_NO_REF(garbage);
39361
0
  }
39362
39363
39364
  /* assign_obj has two opcodes! */
39365
20
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39366
20
}
39367
39368
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39369
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39370
0
{
39371
0
  USE_OPLINE
39372
0
  zval *object, *value, tmp;
39373
0
  zend_object *zobj;
39374
0
  zend_string *name, *tmp_name;
39375
0
  zend_refcounted *garbage = NULL;
39376
39377
0
  SAVE_OPLINE();
39378
0
  object = &EX(This);
39379
0
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
39380
39381
0
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39382
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39383
0
      object = Z_REFVAL_P(object);
39384
0
      goto assign_object;
39385
0
    }
39386
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);
39387
0
    value = &EG(uninitialized_zval);
39388
0
    goto free_and_exit_assign_obj;
39389
0
  }
39390
39391
0
assign_object:
39392
0
  zobj = Z_OBJ_P(object);
39393
0
  if (IS_CV == IS_CONST) {
39394
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39395
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
39396
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39397
0
      zval *property_val;
39398
0
      zend_property_info *prop_info;
39399
39400
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39401
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39402
39403
0
assign_obj_simple:
39404
0
        property_val = OBJ_PROP(zobj, prop_offset);
39405
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
39406
0
          if (prop_info != NULL) {
39407
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39408
0
            goto free_and_exit_assign_obj;
39409
0
          } else {
39410
0
fast_assign_obj:
39411
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
39412
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39413
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
39414
0
            }
39415
0
            goto exit_assign_obj;
39416
0
          }
39417
0
        }
39418
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39419
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39420
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39421
0
          zobj = zend_lazy_object_init(zobj);
39422
0
          if (!zobj) {
39423
0
            value = &EG(uninitialized_zval);
39424
0
            goto free_and_exit_assign_obj;
39425
0
          }
39426
0
        }
39427
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39428
0
          rebuild_object_properties_internal(zobj);
39429
0
        }
39430
0
        if (EXPECTED(zobj->properties != NULL)) {
39431
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39432
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39433
0
              GC_DELREF(zobj->properties);
39434
0
            }
39435
0
            zobj->properties = zend_array_dup(zobj->properties);
39436
0
          }
39437
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
39438
0
          if (property_val) {
39439
0
            goto fast_assign_obj;
39440
0
          }
39441
0
        }
39442
39443
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39444
0
          if (IS_VAR == IS_CONST) {
39445
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39446
0
              Z_ADDREF_P(value);
39447
0
            }
39448
0
          } else if (IS_VAR != IS_TMP_VAR) {
39449
0
            if (Z_ISREF_P(value)) {
39450
0
              if (IS_VAR == IS_VAR) {
39451
0
                zend_reference *ref = Z_REF_P(value);
39452
0
                if (GC_DELREF(ref) == 0) {
39453
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39454
0
                  efree_size(ref, sizeof(zend_reference));
39455
0
                  value = &tmp;
39456
0
                } else {
39457
0
                  value = Z_REFVAL_P(value);
39458
0
                  Z_TRY_ADDREF_P(value);
39459
0
                }
39460
0
              } else {
39461
0
                value = Z_REFVAL_P(value);
39462
0
                Z_TRY_ADDREF_P(value);
39463
0
              }
39464
0
            } else if (IS_VAR == IS_CV) {
39465
0
              Z_TRY_ADDREF_P(value);
39466
0
            }
39467
0
          }
39468
0
          zend_hash_add_new(zobj->properties, name, value);
39469
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39470
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
39471
0
          }
39472
0
          goto exit_assign_obj;
39473
0
        }
39474
0
      } else {
39475
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39476
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39477
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
39478
0
          prop_offset = prop_info->offset;
39479
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39480
0
            prop_info = NULL;
39481
0
          }
39482
0
          goto assign_obj_simple;
39483
0
        }
39484
        /* Fall through to write_property for hooks. */
39485
0
      }
39486
0
    }
39487
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39488
0
  } else {
39489
0
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39490
0
    if (UNEXPECTED(!name)) {
39491
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39492
0
      UNDEF_RESULT();
39493
0
      goto exit_assign_obj;
39494
0
    }
39495
0
  }
39496
39497
0
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
39498
0
    ZVAL_DEREF(value);
39499
0
  }
39500
39501
0
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39502
39503
0
  if (IS_CV != IS_CONST) {
39504
0
    zend_tmp_string_release(tmp_name);
39505
0
  }
39506
39507
0
free_and_exit_assign_obj:
39508
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39509
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39510
0
  }
39511
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39512
0
exit_assign_obj:
39513
0
  if (garbage) {
39514
0
    GC_DTOR_NO_REF(garbage);
39515
0
  }
39516
39517
39518
  /* assign_obj has two opcodes! */
39519
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39520
0
}
39521
39522
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39523
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39524
77
{
39525
77
  USE_OPLINE
39526
77
  zval *object, *value, tmp;
39527
77
  zend_object *zobj;
39528
77
  zend_string *name, *tmp_name;
39529
77
  zend_refcounted *garbage = NULL;
39530
39531
77
  SAVE_OPLINE();
39532
77
  object = &EX(This);
39533
77
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
39534
39535
77
  if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39536
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39537
0
      object = Z_REFVAL_P(object);
39538
0
      goto assign_object;
39539
0
    }
39540
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);
39541
0
    value = &EG(uninitialized_zval);
39542
0
    goto free_and_exit_assign_obj;
39543
0
  }
39544
39545
77
assign_object:
39546
77
  zobj = Z_OBJ_P(object);
39547
77
  if (IS_CV == IS_CONST) {
39548
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39549
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
39550
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39551
0
      zval *property_val;
39552
0
      zend_property_info *prop_info;
39553
39554
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39555
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39556
39557
0
assign_obj_simple:
39558
0
        property_val = OBJ_PROP(zobj, prop_offset);
39559
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
39560
0
          if (prop_info != NULL) {
39561
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39562
0
            goto free_and_exit_assign_obj;
39563
0
          } else {
39564
0
fast_assign_obj:
39565
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
39566
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39567
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
39568
0
            }
39569
0
            goto exit_assign_obj;
39570
0
          }
39571
0
        }
39572
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39573
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39574
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39575
0
          zobj = zend_lazy_object_init(zobj);
39576
0
          if (!zobj) {
39577
0
            value = &EG(uninitialized_zval);
39578
0
            goto free_and_exit_assign_obj;
39579
0
          }
39580
0
        }
39581
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39582
0
          rebuild_object_properties_internal(zobj);
39583
0
        }
39584
0
        if (EXPECTED(zobj->properties != NULL)) {
39585
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39586
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39587
0
              GC_DELREF(zobj->properties);
39588
0
            }
39589
0
            zobj->properties = zend_array_dup(zobj->properties);
39590
0
          }
39591
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
39592
0
          if (property_val) {
39593
0
            goto fast_assign_obj;
39594
0
          }
39595
0
        }
39596
39597
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39598
0
          if (IS_CV == IS_CONST) {
39599
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39600
0
              Z_ADDREF_P(value);
39601
0
            }
39602
0
          } else if (IS_CV != IS_TMP_VAR) {
39603
0
            if (Z_ISREF_P(value)) {
39604
0
              if (IS_CV == IS_VAR) {
39605
0
                zend_reference *ref = Z_REF_P(value);
39606
0
                if (GC_DELREF(ref) == 0) {
39607
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39608
0
                  efree_size(ref, sizeof(zend_reference));
39609
0
                  value = &tmp;
39610
0
                } else {
39611
0
                  value = Z_REFVAL_P(value);
39612
0
                  Z_TRY_ADDREF_P(value);
39613
0
                }
39614
0
              } else {
39615
0
                value = Z_REFVAL_P(value);
39616
0
                Z_TRY_ADDREF_P(value);
39617
0
              }
39618
0
            } else if (IS_CV == IS_CV) {
39619
0
              Z_TRY_ADDREF_P(value);
39620
0
            }
39621
0
          }
39622
0
          zend_hash_add_new(zobj->properties, name, value);
39623
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39624
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
39625
0
          }
39626
0
          goto exit_assign_obj;
39627
0
        }
39628
0
      } else {
39629
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39630
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39631
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
39632
0
          prop_offset = prop_info->offset;
39633
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39634
0
            prop_info = NULL;
39635
0
          }
39636
0
          goto assign_obj_simple;
39637
0
        }
39638
        /* Fall through to write_property for hooks. */
39639
0
      }
39640
0
    }
39641
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39642
77
  } else {
39643
77
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39644
77
    if (UNEXPECTED(!name)) {
39645
39646
0
      UNDEF_RESULT();
39647
0
      goto exit_assign_obj;
39648
0
    }
39649
77
  }
39650
39651
77
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
39652
77
    ZVAL_DEREF(value);
39653
77
  }
39654
39655
77
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39656
39657
77
  if (IS_CV != IS_CONST) {
39658
77
    zend_tmp_string_release(tmp_name);
39659
77
  }
39660
39661
77
free_and_exit_assign_obj:
39662
77
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39663
6
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39664
6
  }
39665
39666
77
exit_assign_obj:
39667
77
  if (garbage) {
39668
0
    GC_DTOR_NO_REF(garbage);
39669
0
  }
39670
39671
39672
  /* assign_obj has two opcodes! */
39673
77
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39674
77
}
39675
39676
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39677
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39678
2
{
39679
2
  USE_OPLINE
39680
2
  zval *property, *container, *value_ptr;
39681
39682
2
  SAVE_OPLINE();
39683
39684
2
  container = &EX(This);
39685
2
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39686
39687
2
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
39688
39689
2
  if (1) {
39690
2
    if (IS_UNUSED == IS_UNUSED) {
39691
2
      if (IS_CV == IS_CONST) {
39692
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39693
2
      } else {
39694
2
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39695
2
      }
39696
2
    } else {
39697
0
      if (IS_CV == IS_CONST) {
39698
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39699
0
      } else {
39700
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39701
0
      }
39702
0
    }
39703
2
  } else {
39704
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39705
0
  }
39706
39707
39708
2
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39709
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39710
2
}
39711
39712
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39713
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39714
2
{
39715
2
  USE_OPLINE
39716
2
  zval *property, *container, *value_ptr;
39717
39718
2
  SAVE_OPLINE();
39719
39720
2
  container = &EX(This);
39721
2
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39722
39723
2
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
39724
39725
2
  if (1) {
39726
2
    if (IS_UNUSED == IS_UNUSED) {
39727
2
      if (IS_CV == IS_CONST) {
39728
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39729
2
      } else {
39730
2
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39731
2
      }
39732
2
    } else {
39733
0
      if (IS_CV == IS_CONST) {
39734
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39735
0
      } else {
39736
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39737
0
      }
39738
0
    }
39739
2
  } else {
39740
0
    zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39741
0
  }
39742
39743
39744
39745
2
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
39746
2
}
39747
39748
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39749
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39750
2.04k
{
39751
2.04k
  USE_OPLINE
39752
2.04k
  zend_string **rope;
39753
2.04k
  zval *var;
39754
39755
  /* Compiler allocates the necessary number of zval slots to keep the rope */
39756
2.04k
  rope = (zend_string**)EX_VAR(opline->result.var);
39757
2.04k
  if (IS_CV == IS_CONST) {
39758
0
    var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39759
0
    rope[0] = Z_STR_P(var);
39760
0
    if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
39761
0
      Z_ADDREF_P(var);
39762
0
    }
39763
2.04k
  } else {
39764
2.04k
    var = EX_VAR(opline->op2.var);
39765
2.04k
    if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
39766
623
      if (IS_CV == IS_CV) {
39767
623
        rope[0] = zend_string_copy(Z_STR_P(var));
39768
623
      } else {
39769
0
        rope[0] = Z_STR_P(var);
39770
0
      }
39771
1.42k
    } else {
39772
1.42k
      SAVE_OPLINE();
39773
1.42k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
39774
488
        ZVAL_UNDEFINED_OP2();
39775
488
      }
39776
1.42k
      rope[0] = zval_get_string_func(var);
39777
39778
1.42k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39779
1.42k
    }
39780
2.04k
  }
39781
623
  ZEND_VM_NEXT_OPCODE();
39782
623
}
39783
39784
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39785
1.73k
{
39786
1.73k
  zval *class_name;
39787
1.73k
  USE_OPLINE
39788
39789
1.73k
  SAVE_OPLINE();
39790
1.73k
  if (IS_CV == IS_UNUSED) {
39791
0
    Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
39792
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39793
1.73k
  } else if (IS_CV == IS_CONST) {
39794
0
    zend_class_entry *ce = CACHED_PTR(opline->extended_value);
39795
39796
0
    if (UNEXPECTED(ce == NULL)) {
39797
0
      class_name = EX_VAR(opline->op2.var);
39798
0
      ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
39799
0
      CACHE_PTR(opline->extended_value, ce);
39800
0
    }
39801
0
    Z_CE_P(EX_VAR(opline->result.var)) = ce;
39802
1.73k
  } else {
39803
1.73k
    class_name = EX_VAR(opline->op2.var);
39804
1.73k
try_class_name:
39805
1.73k
    if (Z_TYPE_P(class_name) == IS_OBJECT) {
39806
114
      Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
39807
1.61k
    } else if (Z_TYPE_P(class_name) == IS_STRING) {
39808
1.27k
      Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
39809
1.27k
    } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
39810
0
      class_name = Z_REFVAL_P(class_name);
39811
0
      goto try_class_name;
39812
344
    } else {
39813
344
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
39814
342
        ZVAL_UNDEFINED_OP2();
39815
342
        if (UNEXPECTED(EG(exception) != NULL)) {
39816
0
          HANDLE_EXCEPTION();
39817
0
        }
39818
342
      }
39819
344
      zend_throw_error(NULL, "Class name must be a valid object or a string");
39820
344
    }
39821
1.73k
  }
39822
39823
1.73k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39824
1.73k
}
39825
39826
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39827
26
{
39828
26
  USE_OPLINE
39829
26
  zval *function_name;
39830
26
  zval *object;
39831
26
  zend_function *fbc;
39832
26
  zend_class_entry *called_scope;
39833
26
  zend_object *obj;
39834
26
  zend_execute_data *call;
39835
26
  uint32_t call_info;
39836
39837
26
  SAVE_OPLINE();
39838
39839
26
  object = &EX(This);
39840
39841
26
  if (IS_CV != IS_CONST) {
39842
26
    function_name = EX_VAR(opline->op2.var);
39843
26
  }
39844
39845
26
  if (IS_CV != IS_CONST &&
39846
26
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
39847
5
    do {
39848
5
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
39849
0
        function_name = Z_REFVAL_P(function_name);
39850
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
39851
0
          break;
39852
0
        }
39853
5
      } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
39854
5
        ZVAL_UNDEFINED_OP2();
39855
5
        if (UNEXPECTED(EG(exception) != NULL)) {
39856
39857
0
          HANDLE_EXCEPTION();
39858
0
        }
39859
5
      }
39860
5
      zend_throw_error(NULL, "Method name must be a string");
39861
39862
39863
5
      HANDLE_EXCEPTION();
39864
5
    } while (0);
39865
5
  }
39866
39867
21
  if (IS_UNUSED == IS_UNUSED) {
39868
21
    obj = Z_OBJ_P(object);
39869
21
  } else {
39870
0
    do {
39871
0
      if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
39872
0
        obj = Z_OBJ_P(object);
39873
0
      } else {
39874
0
        if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
39875
0
          zend_reference *ref = Z_REF_P(object);
39876
39877
0
          object = &ref->val;
39878
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
39879
0
            obj = Z_OBJ_P(object);
39880
0
            if (IS_UNUSED & IS_VAR) {
39881
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
39882
0
                efree_size(ref, sizeof(zend_reference));
39883
0
              } else {
39884
0
                Z_ADDREF_P(object);
39885
0
              }
39886
0
            }
39887
0
            break;
39888
0
          }
39889
0
        }
39890
0
        if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
39891
0
          object = ZVAL_UNDEFINED_OP1();
39892
0
          if (UNEXPECTED(EG(exception) != NULL)) {
39893
0
            if (IS_CV != IS_CONST) {
39894
39895
0
            }
39896
0
            HANDLE_EXCEPTION();
39897
0
          }
39898
0
        }
39899
0
        if (IS_CV == IS_CONST) {
39900
0
          function_name = EX_VAR(opline->op2.var);
39901
0
        }
39902
0
        zend_invalid_method_call(object, function_name);
39903
39904
39905
0
        HANDLE_EXCEPTION();
39906
0
      }
39907
0
    } while (0);
39908
0
  }
39909
39910
21
  called_scope = obj->ce;
39911
39912
21
  if (IS_CV == IS_CONST &&
39913
21
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
39914
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
39915
21
  } else {
39916
21
    zend_object *orig_obj = obj;
39917
39918
21
    if (IS_CV == IS_CONST) {
39919
0
      function_name = EX_VAR(opline->op2.var);
39920
0
    }
39921
39922
    /* First, locate the function. */
39923
21
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
39924
21
    if (UNEXPECTED(fbc == NULL)) {
39925
3
      if (EXPECTED(!EG(exception))) {
39926
3
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
39927
3
      }
39928
39929
3
      if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
39930
0
        zend_objects_store_del(orig_obj);
39931
0
      }
39932
3
      HANDLE_EXCEPTION();
39933
3
    }
39934
18
    if (IS_CV == IS_CONST &&
39935
18
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
39936
18
        EXPECTED(obj == orig_obj)) {
39937
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
39938
0
    }
39939
18
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
39940
0
      GC_ADDREF(obj); /* For $this pointer */
39941
0
      if (GC_DELREF(orig_obj) == 0) {
39942
0
        zend_objects_store_del(orig_obj);
39943
0
      }
39944
0
    }
39945
18
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
39946
5
      init_func_run_time_cache(&fbc->op_array);
39947
5
    }
39948
18
  }
39949
39950
18
  if (IS_CV != IS_CONST) {
39951
39952
18
  }
39953
39954
18
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
39955
18
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
39956
0
    if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
39957
0
      zend_objects_store_del(obj);
39958
0
      if (UNEXPECTED(EG(exception))) {
39959
0
        HANDLE_EXCEPTION();
39960
0
      }
39961
0
    }
39962
    /* call static method */
39963
0
    obj = (zend_object*)called_scope;
39964
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
39965
18
  } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
39966
0
    if (IS_UNUSED == IS_CV) {
39967
0
      GC_ADDREF(obj); /* For $this pointer */
39968
0
    }
39969
    /* CV may be changed indirectly (e.g. when it's a reference) */
39970
0
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
39971
0
  }
39972
39973
18
  call = zend_vm_stack_push_call_frame(call_info,
39974
18
    fbc, opline->extended_value, obj);
39975
18
  call->prev_execute_data = EX(call);
39976
18
  EX(call) = call;
39977
39978
18
  ZEND_VM_NEXT_OPCODE();
39979
18
}
39980
39981
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39982
18
{
39983
18
  USE_OPLINE
39984
18
  zval *function_name;
39985
18
  zend_class_entry *ce;
39986
18
  uint32_t call_info;
39987
18
  zend_function *fbc;
39988
18
  zend_execute_data *call;
39989
39990
18
  SAVE_OPLINE();
39991
39992
18
  if (IS_UNUSED == IS_CONST) {
39993
    /* no function found. try a static method in class */
39994
0
    ce = CACHED_PTR(opline->result.num);
39995
0
    if (UNEXPECTED(ce == NULL)) {
39996
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);
39997
0
      if (UNEXPECTED(ce == NULL)) {
39998
39999
0
        HANDLE_EXCEPTION();
40000
0
      }
40001
0
      if (IS_CV != IS_CONST) {
40002
0
        CACHE_PTR(opline->result.num, ce);
40003
0
      }
40004
0
    }
40005
18
  } else if (IS_UNUSED == IS_UNUSED) {
40006
18
    ce = zend_fetch_class(NULL, opline->op1.num);
40007
18
    if (UNEXPECTED(ce == NULL)) {
40008
40009
5
      HANDLE_EXCEPTION();
40010
5
    }
40011
18
  } else {
40012
0
    ce = Z_CE_P(EX_VAR(opline->op1.var));
40013
0
  }
40014
40015
13
  if (IS_UNUSED == IS_CONST &&
40016
13
      IS_CV == IS_CONST &&
40017
13
      EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
40018
    /* nothing to do */
40019
13
  } else if (IS_UNUSED != IS_CONST &&
40020
13
             IS_CV == IS_CONST &&
40021
13
             EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
40022
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
40023
13
  } else if (IS_CV != IS_UNUSED) {
40024
13
    function_name = EX_VAR(opline->op2.var);
40025
13
    if (IS_CV != IS_CONST) {
40026
13
      if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
40027
13
        do {
40028
13
          if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
40029
10
            function_name = Z_REFVAL_P(function_name);
40030
10
            if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
40031
10
              break;
40032
10
            }
40033
10
          } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
40034
3
            ZVAL_UNDEFINED_OP2();
40035
3
            if (UNEXPECTED(EG(exception) != NULL)) {
40036
0
              HANDLE_EXCEPTION();
40037
0
            }
40038
3
          }
40039
3
          zend_throw_error(NULL, "Method name must be a string");
40040
40041
3
          HANDLE_EXCEPTION();
40042
3
        } while (0);
40043
13
      }
40044
13
    }
40045
40046
10
    if (ce->get_static_method) {
40047
0
      fbc = ce->get_static_method(ce, Z_STR_P(function_name));
40048
10
    } else {
40049
10
      fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
40050
10
    }
40051
10
    if (UNEXPECTED(fbc == NULL)) {
40052
5
      if (EXPECTED(!EG(exception))) {
40053
5
        zend_undefined_method(ce, Z_STR_P(function_name));
40054
5
      }
40055
40056
5
      HANDLE_EXCEPTION();
40057
5
    }
40058
5
    if (IS_CV == IS_CONST &&
40059
5
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
40060
5
      EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
40061
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
40062
0
    }
40063
5
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
40064
5
      init_func_run_time_cache(&fbc->op_array);
40065
5
    }
40066
5
    if (IS_CV != IS_CONST) {
40067
40068
5
    }
40069
5
  } else {
40070
0
    if (UNEXPECTED(ce->constructor == NULL)) {
40071
0
      zend_throw_error(NULL, "Cannot call constructor");
40072
0
      HANDLE_EXCEPTION();
40073
0
    }
40074
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)) {
40075
0
      zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
40076
0
      HANDLE_EXCEPTION();
40077
0
    }
40078
0
    fbc = ce->constructor;
40079
0
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
40080
0
      init_func_run_time_cache(&fbc->op_array);
40081
0
    }
40082
0
  }
40083
40084
5
  if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
40085
0
    if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
40086
0
      ce = (zend_class_entry*)Z_OBJ(EX(This));
40087
0
      call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
40088
0
    } else {
40089
0
      zend_non_static_method_call(fbc);
40090
0
      HANDLE_EXCEPTION();
40091
0
    }
40092
5
  } else {
40093
    /* previous opcode is ZEND_FETCH_CLASS */
40094
5
    if (IS_UNUSED == IS_UNUSED
40095
5
     && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
40096
5
         (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
40097
5
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
40098
0
        ce = Z_OBJCE(EX(This));
40099
5
      } else {
40100
5
        ce = Z_CE(EX(This));
40101
5
      }
40102
5
    }
40103
5
    call_info = ZEND_CALL_NESTED_FUNCTION;
40104
5
  }
40105
40106
5
  call = zend_vm_stack_push_call_frame(call_info,
40107
5
    fbc, opline->extended_value, ce);
40108
5
  call->prev_execute_data = EX(call);
40109
5
  EX(call) = call;
40110
40111
5
  ZEND_VM_NEXT_OPCODE();
40112
5
}
40113
40114
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40115
0
{
40116
0
  zval *array;
40117
0
  uint32_t size;
40118
0
  USE_OPLINE
40119
40120
0
  SAVE_OPLINE();
40121
0
  array = EX_VAR(opline->result.var);
40122
0
  if (IS_UNUSED != IS_UNUSED) {
40123
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
40124
0
    ZVAL_ARR(array, zend_new_array(size));
40125
    /* Explicitly initialize array as not-packed if flag is set */
40126
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
40127
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
40128
0
    }
40129
0
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40130
0
  } else {
40131
0
    ZVAL_ARR(array, zend_new_array(0));
40132
0
    ZEND_VM_NEXT_OPCODE();
40133
0
  }
40134
0
}
40135
40136
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40137
25
{
40138
25
  USE_OPLINE
40139
25
  zval *container;
40140
25
  zval *offset;
40141
25
  zend_string *name, *tmp_name;
40142
40143
25
  SAVE_OPLINE();
40144
25
  container = &EX(This);
40145
25
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40146
40147
25
  do {
40148
25
    if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
40149
0
      if (Z_ISREF_P(container)) {
40150
0
        container = Z_REFVAL_P(container);
40151
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
40152
0
          if (IS_UNUSED == IS_CV
40153
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
40154
0
            ZVAL_UNDEFINED_OP1();
40155
0
          }
40156
0
          break;
40157
0
        }
40158
0
      } else {
40159
0
        break;
40160
0
      }
40161
0
    }
40162
25
    if (IS_CV == IS_CONST) {
40163
0
      name = Z_STR_P(offset);
40164
25
    } else {
40165
25
      name = zval_try_get_tmp_string(offset, &tmp_name);
40166
25
      if (UNEXPECTED(!name)) {
40167
0
        break;
40168
0
      }
40169
25
    }
40170
25
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
40171
25
    if (IS_CV != IS_CONST) {
40172
25
      zend_tmp_string_release(tmp_name);
40173
25
    }
40174
25
  } while (0);
40175
40176
40177
25
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40178
25
}
40179
40180
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40181
50
{
40182
50
  USE_OPLINE
40183
50
  zval *container;
40184
50
  int result;
40185
50
  zval *offset;
40186
50
  zend_string *name, *tmp_name;
40187
40188
50
  SAVE_OPLINE();
40189
50
  container = &EX(This);
40190
50
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40191
40192
50
  if (IS_UNUSED == IS_CONST ||
40193
50
      (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
40194
0
    if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
40195
0
      container = Z_REFVAL_P(container);
40196
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
40197
0
        result = (opline->extended_value & ZEND_ISEMPTY);
40198
0
        goto isset_object_finish;
40199
0
      }
40200
0
    } else {
40201
0
      result = (opline->extended_value & ZEND_ISEMPTY);
40202
0
      goto isset_object_finish;
40203
0
    }
40204
0
  }
40205
40206
50
  if (IS_CV == IS_CONST) {
40207
0
    name = Z_STR_P(offset);
40208
50
  } else {
40209
50
    name = zval_try_get_tmp_string(offset, &tmp_name);
40210
50
    if (UNEXPECTED(!name)) {
40211
0
      result = 0;
40212
0
      goto isset_object_finish;
40213
0
    }
40214
50
  }
40215
40216
50
  result =
40217
50
    (opline->extended_value & ZEND_ISEMPTY) ^
40218
50
    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));
40219
40220
50
  if (IS_CV != IS_CONST) {
40221
50
    zend_tmp_string_release(tmp_name);
40222
50
  }
40223
40224
50
isset_object_finish:
40225
40226
40227
50
  ZEND_VM_SMART_BRANCH(result, 1);
40228
50
}
40229
40230
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40231
0
{
40232
0
  USE_OPLINE
40233
40234
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40235
40236
0
  SAVE_OPLINE();
40237
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
40238
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40239
0
  }
40240
40241
  /* Destroy the previously yielded value */
40242
0
  zval_ptr_dtor(&generator->value);
40243
40244
  /* Destroy the previously yielded key */
40245
0
  zval_ptr_dtor(&generator->key);
40246
40247
  /* Set the new yielded value */
40248
0
  if (IS_UNUSED != IS_UNUSED) {
40249
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
40250
      /* Constants and temporary variables aren't yieldable by reference,
40251
       * but we still allow them with a notice. */
40252
0
      if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
40253
0
        zval *value;
40254
40255
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
40256
40257
0
        value = NULL;
40258
0
        ZVAL_COPY_VALUE(&generator->value, value);
40259
0
        if (IS_UNUSED == IS_CONST) {
40260
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
40261
0
            Z_ADDREF(generator->value);
40262
0
          }
40263
0
        }
40264
0
      } else {
40265
0
        zval *value_ptr = NULL;
40266
40267
        /* If a function call result is yielded and the function did
40268
         * not return by reference we throw a notice. */
40269
0
        do {
40270
0
          if (IS_UNUSED == IS_VAR) {
40271
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
40272
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
40273
0
             && !Z_ISREF_P(value_ptr)) {
40274
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
40275
0
              ZVAL_COPY(&generator->value, value_ptr);
40276
0
              break;
40277
0
            }
40278
0
          }
40279
0
          if (Z_ISREF_P(value_ptr)) {
40280
0
            Z_ADDREF_P(value_ptr);
40281
0
          } else {
40282
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
40283
0
          }
40284
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
40285
0
        } while (0);
40286
40287
0
      }
40288
0
    } else {
40289
0
      zval *value = NULL;
40290
40291
      /* Consts, temporary variables and references need copying */
40292
0
      if (IS_UNUSED == IS_CONST) {
40293
0
        ZVAL_COPY_VALUE(&generator->value, value);
40294
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
40295
0
          Z_ADDREF(generator->value);
40296
0
        }
40297
0
      } else if (IS_UNUSED == IS_TMP_VAR) {
40298
0
        ZVAL_COPY_VALUE(&generator->value, value);
40299
0
      } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40300
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
40301
40302
0
      } else {
40303
0
        ZVAL_COPY_VALUE(&generator->value, value);
40304
0
        if (IS_UNUSED == IS_CV) {
40305
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
40306
0
        }
40307
0
      }
40308
0
    }
40309
0
  } else {
40310
    /* If no value was specified yield null */
40311
0
    ZVAL_NULL(&generator->value);
40312
0
  }
40313
40314
  /* Set the new yielded key */
40315
0
  if (IS_CV != IS_UNUSED) {
40316
0
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40317
0
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
40318
0
      key = Z_REFVAL_P(key);
40319
0
    }
40320
0
    ZVAL_COPY(&generator->key, key);
40321
40322
0
    if (Z_TYPE(generator->key) == IS_LONG
40323
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
40324
0
    ) {
40325
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
40326
0
    }
40327
0
  } else {
40328
    /* If no key was specified we use auto-increment keys */
40329
0
    generator->largest_used_integer_key++;
40330
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
40331
0
  }
40332
40333
0
  if (RETURN_VALUE_USED(opline)) {
40334
    /* If the return value of yield is used set the send
40335
     * target and initialize it to NULL */
40336
0
    generator->send_target = EX_VAR(opline->result.var);
40337
0
    ZVAL_NULL(generator->send_target);
40338
0
  } else {
40339
0
    generator->send_target = NULL;
40340
0
  }
40341
40342
  /* The GOTO VM uses a local opline variable. We need to set the opline
40343
   * variable in execute_data so we don't resume at an old position. */
40344
0
  SAVE_OPLINE();
40345
40346
0
  ZEND_VM_RETURN();
40347
0
}
40348
40349
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40350
11.9k
{
40351
11.9k
  USE_OPLINE
40352
11.9k
  zval *val;
40353
40354
11.9k
  val = EX_VAR(opline->op1.var);
40355
11.9k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40356
325
    ZVAL_FALSE(EX_VAR(opline->result.var));
40357
11.6k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40358
    /* The result and op1 can be the same cv zval */
40359
2.57k
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
40360
2.57k
    ZVAL_TRUE(EX_VAR(opline->result.var));
40361
2.57k
    if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
40362
2.21k
      SAVE_OPLINE();
40363
2.21k
      ZVAL_UNDEFINED_OP1();
40364
2.21k
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40365
2.21k
    }
40366
9.08k
  } else {
40367
9.08k
    SAVE_OPLINE();
40368
9.08k
    ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
40369
40370
9.08k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40371
9.08k
  }
40372
685
  ZEND_VM_NEXT_OPCODE();
40373
685
}
40374
40375
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40376
5.66k
{
40377
5.66k
  USE_OPLINE
40378
5.66k
  zval *var_ptr;
40379
40380
5.66k
  var_ptr = EX_VAR(opline->op1.var);
40381
40382
5.66k
  SAVE_OPLINE();
40383
5.66k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40384
1.17k
    ZVAL_UNDEFINED_OP1();
40385
1.17k
    ZVAL_NULL(var_ptr);
40386
1.17k
  }
40387
40388
5.66k
  do {
40389
5.66k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40390
1.83k
      zend_reference *ref = Z_REF_P(var_ptr);
40391
1.83k
      var_ptr = Z_REFVAL_P(var_ptr);
40392
1.83k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40393
62
        zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
40394
62
        break;
40395
62
      }
40396
1.83k
    }
40397
5.60k
    increment_function(var_ptr);
40398
5.60k
  } while (0);
40399
40400
5.66k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
40401
1.07k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40402
1.07k
  }
40403
40404
5.66k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40405
5.66k
}
40406
40407
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40408
77.4k
{
40409
77.4k
  USE_OPLINE
40410
77.4k
  zval *var_ptr;
40411
40412
77.4k
  var_ptr = EX_VAR(opline->op1.var);
40413
40414
77.4k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40415
72.8k
    fast_long_increment_function(var_ptr);
40416
72.8k
    if (UNEXPECTED(0)) {
40417
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40418
0
    }
40419
72.8k
    ZEND_VM_NEXT_OPCODE();
40420
72.8k
  }
40421
40422
77.4k
  ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40423
77.4k
}
40424
40425
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40426
5.70k
{
40427
5.70k
  USE_OPLINE
40428
5.70k
  zval *var_ptr;
40429
40430
5.70k
  var_ptr = EX_VAR(opline->op1.var);
40431
40432
5.70k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40433
4.62k
    fast_long_increment_function(var_ptr);
40434
4.62k
    if (UNEXPECTED(1)) {
40435
4.62k
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40436
4.62k
    }
40437
4.62k
    ZEND_VM_NEXT_OPCODE();
40438
4.62k
  }
40439
40440
5.70k
  ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40441
5.70k
}
40442
40443
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40444
4.10k
{
40445
4.10k
  USE_OPLINE
40446
4.10k
  zval *var_ptr;
40447
40448
4.10k
  var_ptr = EX_VAR(opline->op1.var);
40449
40450
4.10k
  SAVE_OPLINE();
40451
4.10k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40452
145
    ZVAL_UNDEFINED_OP1();
40453
145
    ZVAL_NULL(var_ptr);
40454
145
  }
40455
40456
4.10k
  do {
40457
4.10k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40458
71
      zend_reference *ref = Z_REF_P(var_ptr);
40459
71
      var_ptr = Z_REFVAL_P(var_ptr);
40460
40461
71
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40462
59
        zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
40463
59
        break;
40464
59
      }
40465
71
    }
40466
4.04k
    decrement_function(var_ptr);
40467
4.04k
  } while (0);
40468
40469
4.10k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
40470
1.85k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40471
1.85k
  }
40472
40473
4.10k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40474
4.10k
}
40475
40476
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40477
2.90k
{
40478
2.90k
  USE_OPLINE
40479
2.90k
  zval *var_ptr;
40480
40481
2.90k
  var_ptr = EX_VAR(opline->op1.var);
40482
40483
2.90k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40484
650
    fast_long_decrement_function(var_ptr);
40485
650
    if (UNEXPECTED(0)) {
40486
0
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40487
0
    }
40488
650
    ZEND_VM_NEXT_OPCODE();
40489
650
  }
40490
40491
2.90k
  ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40492
2.90k
}
40493
40494
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40495
5.40k
{
40496
5.40k
  USE_OPLINE
40497
5.40k
  zval *var_ptr;
40498
40499
5.40k
  var_ptr = EX_VAR(opline->op1.var);
40500
40501
5.40k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40502
3.54k
    fast_long_decrement_function(var_ptr);
40503
3.54k
    if (UNEXPECTED(1)) {
40504
3.54k
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40505
3.54k
    }
40506
3.54k
    ZEND_VM_NEXT_OPCODE();
40507
3.54k
  }
40508
40509
5.40k
  ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40510
5.40k
}
40511
40512
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40513
388
{
40514
388
  USE_OPLINE
40515
388
  zval *var_ptr;
40516
40517
388
  var_ptr = EX_VAR(opline->op1.var);
40518
40519
388
  SAVE_OPLINE();
40520
388
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40521
164
    ZVAL_UNDEFINED_OP1();
40522
164
    ZVAL_NULL(var_ptr);
40523
164
  }
40524
40525
388
  do {
40526
388
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40527
119
      zend_reference *ref = Z_REF_P(var_ptr);
40528
119
      var_ptr = Z_REFVAL_P(var_ptr);
40529
40530
119
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40531
35
        zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
40532
35
        break;
40533
35
      }
40534
119
    }
40535
353
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40536
40537
353
    increment_function(var_ptr);
40538
353
  } while (0);
40539
40540
388
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40541
388
}
40542
40543
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40544
6.57k
{
40545
6.57k
  USE_OPLINE
40546
6.57k
  zval *var_ptr;
40547
40548
6.57k
  var_ptr = EX_VAR(opline->op1.var);
40549
40550
6.57k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40551
6.18k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40552
6.18k
    fast_long_increment_function(var_ptr);
40553
6.18k
    ZEND_VM_NEXT_OPCODE();
40554
6.18k
  }
40555
40556
6.57k
  ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40557
6.57k
}
40558
40559
static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40560
15.0k
{
40561
15.0k
  USE_OPLINE
40562
15.0k
  zval *var_ptr;
40563
40564
15.0k
  var_ptr = EX_VAR(opline->op1.var);
40565
40566
15.0k
  SAVE_OPLINE();
40567
15.0k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40568
382
    ZVAL_UNDEFINED_OP1();
40569
382
    ZVAL_NULL(var_ptr);
40570
382
  }
40571
40572
15.0k
  do {
40573
15.0k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40574
2.79k
      zend_reference *ref = Z_REF_P(var_ptr);
40575
2.79k
      var_ptr = Z_REFVAL_P(var_ptr);
40576
40577
2.79k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40578
34
        zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
40579
34
        break;
40580
34
      }
40581
2.79k
    }
40582
15.0k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40583
40584
15.0k
    decrement_function(var_ptr);
40585
15.0k
  } while (0);
40586
40587
15.0k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40588
15.0k
}
40589
40590
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40591
32.2k
{
40592
32.2k
  USE_OPLINE
40593
32.2k
  zval *var_ptr;
40594
40595
32.2k
  var_ptr = EX_VAR(opline->op1.var);
40596
40597
32.2k
  if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40598
17.1k
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40599
17.1k
    fast_long_decrement_function(var_ptr);
40600
17.1k
    ZEND_VM_NEXT_OPCODE();
40601
17.1k
  }
40602
40603
32.2k
  ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40604
32.2k
}
40605
40606
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40607
2.17k
{
40608
2.17k
  USE_OPLINE
40609
2.17k
  zval *z;
40610
40611
2.17k
  SAVE_OPLINE();
40612
2.17k
  z = EX_VAR(opline->op1.var);
40613
40614
2.17k
  if (Z_TYPE_P(z) == IS_STRING) {
40615
934
    zend_string *str = Z_STR_P(z);
40616
40617
934
    if (ZSTR_LEN(str) != 0) {
40618
931
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
40619
931
    }
40620
1.24k
  } else {
40621
1.24k
    zend_string *str = zval_get_string_func(z);
40622
40623
1.24k
    if (ZSTR_LEN(str) != 0) {
40624
456
      zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
40625
786
    } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
40626
681
      ZVAL_UNDEFINED_OP1();
40627
681
    }
40628
1.24k
    zend_string_release_ex(str, 0);
40629
1.24k
  }
40630
40631
2.17k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40632
2.17k
}
40633
40634
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40635
6.59k
{
40636
6.59k
  USE_OPLINE
40637
6.59k
  zval *val;
40638
6.59k
  uint8_t op1_type;
40639
40640
6.59k
  val = EX_VAR(opline->op1.var);
40641
40642
6.59k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40643
850
    ZEND_VM_NEXT_OPCODE();
40644
5.74k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40645
1.68k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40646
829
      SAVE_OPLINE();
40647
829
      ZVAL_UNDEFINED_OP1();
40648
829
      if (UNEXPECTED(EG(exception))) {
40649
0
        HANDLE_EXCEPTION();
40650
0
      }
40651
829
    }
40652
1.68k
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40653
1.68k
  }
40654
40655
6.59k
  SAVE_OPLINE();
40656
4.06k
  op1_type = IS_CV;
40657
4.06k
  if (i_zend_is_true(val)) {
40658
2.17k
    opline++;
40659
2.17k
  } else {
40660
1.89k
    opline = OP_JMP_ADDR(opline, opline->op2);
40661
1.89k
  }
40662
4.06k
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
40663
0
    zval_ptr_dtor_nogc(val);
40664
0
  }
40665
4.06k
  ZEND_VM_JMP(opline);
40666
4.06k
}
40667
40668
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40669
9.13k
{
40670
9.13k
  USE_OPLINE
40671
9.13k
  zval *val;
40672
9.13k
  uint8_t op1_type;
40673
40674
9.13k
  val = EX_VAR(opline->op1.var);
40675
40676
9.13k
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40677
21
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40678
9.10k
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40679
3.96k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40680
2.52k
      SAVE_OPLINE();
40681
2.52k
      ZVAL_UNDEFINED_OP1();
40682
2.52k
      if (UNEXPECTED(EG(exception))) {
40683
0
        HANDLE_EXCEPTION();
40684
0
      }
40685
2.52k
    }
40686
3.96k
    ZEND_VM_NEXT_OPCODE();
40687
3.96k
  }
40688
40689
9.13k
  SAVE_OPLINE();
40690
5.14k
  op1_type = IS_CV;
40691
5.14k
  if (i_zend_is_true(val)) {
40692
2.74k
    opline = OP_JMP_ADDR(opline, opline->op2);
40693
2.74k
  } else {
40694
2.40k
    opline++;
40695
2.40k
  }
40696
5.14k
  if (op1_type & (IS_TMP_VAR|IS_VAR)) {
40697
0
    zval_ptr_dtor_nogc(val);
40698
0
  }
40699
5.14k
  ZEND_VM_JMP(opline);
40700
5.14k
}
40701
40702
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40703
15
{
40704
15
  USE_OPLINE
40705
15
  zval *val;
40706
15
  bool ret;
40707
40708
15
  val = EX_VAR(opline->op1.var);
40709
40710
15
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40711
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
40712
0
    ZEND_VM_NEXT_OPCODE();
40713
15
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40714
0
    ZVAL_FALSE(EX_VAR(opline->result.var));
40715
0
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40716
0
      SAVE_OPLINE();
40717
0
      ZVAL_UNDEFINED_OP1();
40718
0
      if (UNEXPECTED(EG(exception))) {
40719
0
        HANDLE_EXCEPTION();
40720
0
      }
40721
0
    }
40722
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40723
0
  }
40724
40725
15
  SAVE_OPLINE();
40726
15
  ret = i_zend_is_true(val);
40727
40728
15
  if (ret) {
40729
10
    ZVAL_TRUE(EX_VAR(opline->result.var));
40730
10
    opline++;
40731
10
  } else {
40732
5
    ZVAL_FALSE(EX_VAR(opline->result.var));
40733
5
    opline = OP_JMP_ADDR(opline, opline->op2);
40734
5
  }
40735
15
  ZEND_VM_JMP(opline);
40736
15
}
40737
40738
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40739
41
{
40740
41
  USE_OPLINE
40741
41
  zval *val;
40742
41
  bool ret;
40743
40744
41
  val = EX_VAR(opline->op1.var);
40745
40746
41
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40747
0
    ZVAL_TRUE(EX_VAR(opline->result.var));
40748
0
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40749
41
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40750
2
    ZVAL_FALSE(EX_VAR(opline->result.var));
40751
2
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40752
2
      SAVE_OPLINE();
40753
2
      ZVAL_UNDEFINED_OP1();
40754
2
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40755
2
    } else {
40756
0
      ZEND_VM_NEXT_OPCODE();
40757
0
    }
40758
2
  }
40759
40760
41
  SAVE_OPLINE();
40761
39
  ret = i_zend_is_true(val);
40762
40763
39
  if (ret) {
40764
30
    ZVAL_TRUE(EX_VAR(opline->result.var));
40765
30
    opline = OP_JMP_ADDR(opline, opline->op2);
40766
30
  } else {
40767
9
    ZVAL_FALSE(EX_VAR(opline->result.var));
40768
9
    opline++;
40769
9
  }
40770
39
  ZEND_VM_JMP(opline);
40771
39
}
40772
40773
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40774
3.88k
{
40775
3.88k
  USE_OPLINE
40776
3.88k
  zval *retval_ptr;
40777
3.88k
  zval *return_value;
40778
40779
3.88k
  retval_ptr = EX_VAR(opline->op1.var);
40780
3.88k
  return_value = EX(return_value);
40781
40782
3.88k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
40783
366
    SAVE_OPLINE();
40784
366
    retval_ptr = ZVAL_UNDEFINED_OP1();
40785
366
    if (return_value) {
40786
262
      ZVAL_NULL(return_value);
40787
262
    }
40788
3.52k
  } else if (!return_value) {
40789
390
    if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
40790
0
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
40791
0
        SAVE_OPLINE();
40792
0
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
40793
0
      }
40794
0
    }
40795
3.13k
  } else {
40796
3.13k
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
40797
0
      ZVAL_COPY_VALUE(return_value, retval_ptr);
40798
0
      if (IS_CV == IS_CONST) {
40799
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
40800
0
          Z_ADDREF_P(return_value);
40801
0
        }
40802
0
      }
40803
3.13k
    } else if (IS_CV == IS_CV) {
40804
3.13k
      do {
40805
3.13k
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40806
1.46k
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
40807
984
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
40808
984
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
40809
984
              ZVAL_COPY_VALUE(return_value, retval_ptr);
40810
984
              if (GC_MAY_LEAK(ref)) {
40811
593
                SAVE_OPLINE();
40812
593
                gc_possible_root(ref);
40813
593
              }
40814
984
              ZVAL_NULL(retval_ptr);
40815
984
              break;
40816
984
            } else {
40817
0
              Z_ADDREF_P(retval_ptr);
40818
0
            }
40819
984
          } else {
40820
480
            retval_ptr = Z_REFVAL_P(retval_ptr);
40821
480
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40822
243
              Z_ADDREF_P(retval_ptr);
40823
243
            }
40824
480
          }
40825
1.46k
        }
40826
2.14k
        ZVAL_COPY_VALUE(return_value, retval_ptr);
40827
2.14k
      } while (0);
40828
3.13k
    } else /* if (IS_CV == IS_VAR) */ {
40829
0
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
40830
0
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
40831
40832
0
        retval_ptr = Z_REFVAL_P(retval_ptr);
40833
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
40834
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40835
0
          efree_size(ref, sizeof(zend_reference));
40836
0
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40837
0
          Z_ADDREF_P(retval_ptr);
40838
0
        }
40839
0
      } else {
40840
0
        ZVAL_COPY_VALUE(return_value, retval_ptr);
40841
0
      }
40842
0
    }
40843
3.13k
  }
40844
40845
40846
40847
3.88k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40848
3.88k
}
40849
40850
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40851
1.27k
{
40852
1.27k
  USE_OPLINE
40853
1.27k
  zval *retval_ptr;
40854
1.27k
  zval *return_value;
40855
40856
1.27k
  SAVE_OPLINE();
40857
40858
1.27k
  return_value = EX(return_value);
40859
40860
1.27k
  do {
40861
1.27k
    if ((IS_CV & (IS_CONST|IS_TMP_VAR)) ||
40862
1.27k
        (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
40863
      /* Not supposed to happen, but we'll allow it */
40864
0
      zend_error(E_NOTICE, "Only variable references should be returned by reference");
40865
40866
0
      retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40867
0
      if (!return_value) {
40868
40869
0
      } else {
40870
0
        if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
40871
0
          ZVAL_COPY_VALUE(return_value, retval_ptr);
40872
0
          break;
40873
0
        }
40874
40875
0
        ZVAL_NEW_REF(return_value, retval_ptr);
40876
0
        if (IS_CV == IS_CONST) {
40877
0
          Z_TRY_ADDREF_P(retval_ptr);
40878
0
        }
40879
0
      }
40880
0
      break;
40881
0
    }
40882
40883
1.27k
    retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
40884
40885
1.27k
    if (IS_CV == IS_VAR) {
40886
0
      ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
40887
0
      if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
40888
0
        zend_error(E_NOTICE, "Only variable references should be returned by reference");
40889
0
        if (return_value) {
40890
0
          ZVAL_NEW_REF(return_value, retval_ptr);
40891
0
        } else {
40892
40893
0
        }
40894
0
        break;
40895
0
      }
40896
0
    }
40897
40898
1.27k
    if (return_value) {
40899
1.25k
      if (Z_ISREF_P(retval_ptr)) {
40900
568
        Z_ADDREF_P(retval_ptr);
40901
686
      } else {
40902
686
        ZVAL_MAKE_REF_EX(retval_ptr, 2);
40903
686
      }
40904
1.25k
      ZVAL_REF(return_value, Z_REF_P(retval_ptr));
40905
1.25k
    }
40906
40907
1.27k
  } while (0);
40908
40909
40910
1.27k
  ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40911
1.27k
}
40912
40913
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40914
5
{
40915
5
  USE_OPLINE
40916
5
  zval *retval;
40917
40918
5
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40919
40920
5
  SAVE_OPLINE();
40921
5
  retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40922
40923
  /* Copy return value into generator->retval */
40924
5
  if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
40925
0
    ZVAL_COPY_VALUE(&generator->retval, retval);
40926
0
    if (IS_CV == IS_CONST) {
40927
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
40928
0
        Z_ADDREF(generator->retval);
40929
0
      }
40930
0
    }
40931
5
  } else if (IS_CV == IS_CV) {
40932
5
    ZVAL_COPY_DEREF(&generator->retval, retval);
40933
5
  } else /* if (IS_CV == IS_VAR) */ {
40934
0
    if (UNEXPECTED(Z_ISREF_P(retval))) {
40935
0
      zend_refcounted *ref = Z_COUNTED_P(retval);
40936
40937
0
      retval = Z_REFVAL_P(retval);
40938
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
40939
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40940
0
        efree_size(ref, sizeof(zend_reference));
40941
0
      } else if (Z_OPT_REFCOUNTED_P(retval)) {
40942
0
        Z_ADDREF_P(retval);
40943
0
      }
40944
0
    } else {
40945
0
      ZVAL_COPY_VALUE(&generator->retval, retval);
40946
0
    }
40947
0
  }
40948
40949
5
  EG(current_execute_data) = EX(prev_execute_data);
40950
40951
  /* Close the generator to free up resources */
40952
5
  zend_generator_close(generator, 1);
40953
40954
  /* Pass execution back to handling code */
40955
5
  ZEND_VM_RETURN();
40956
5
}
40957
40958
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40959
71
{
40960
71
  USE_OPLINE
40961
71
  zval *value;
40962
40963
71
  SAVE_OPLINE();
40964
71
  value = EX_VAR(opline->op1.var);
40965
40966
71
  do {
40967
71
    if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
40968
9
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40969
5
        value = Z_REFVAL_P(value);
40970
5
        if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
40971
5
          break;
40972
5
        }
40973
5
      }
40974
4
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40975
4
        ZVAL_UNDEFINED_OP1();
40976
4
        if (UNEXPECTED(EG(exception) != NULL)) {
40977
0
          HANDLE_EXCEPTION();
40978
0
        }
40979
4
      }
40980
4
      zend_throw_error(NULL, "Can only throw objects");
40981
40982
4
      HANDLE_EXCEPTION();
40983
4
    }
40984
71
  } while (0);
40985
40986
67
  zend_exception_save();
40987
67
  Z_TRY_ADDREF_P(value);
40988
67
  zend_throw_exception_object(value);
40989
67
  zend_exception_restore();
40990
40991
67
  HANDLE_EXCEPTION();
40992
67
}
40993
40994
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40995
2.01k
{
40996
2.01k
  USE_OPLINE
40997
2.01k
  zval *arg, *param;
40998
40999
2.01k
  SAVE_OPLINE();
41000
41001
2.01k
  arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41002
2.01k
  param = ZEND_CALL_VAR(EX(call), opline->result.var);
41003
2.01k
  if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
41004
41
    zend_param_must_be_ref(EX(call)->func, opline->op2.num);
41005
41
    Z_TRY_ADDREF_P(arg);
41006
41
    ZVAL_NEW_REF(param, arg);
41007
1.97k
  } else {
41008
1.97k
    ZVAL_COPY(param, arg);
41009
1.97k
  }
41010
41011
2.01k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41012
2.01k
}
41013
41014
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41015
533
{
41016
533
  USE_OPLINE
41017
533
  zval *val;
41018
41019
533
  val = EX_VAR(opline->op1.var);
41020
533
  if (Z_TYPE_INFO_P(val) == IS_TRUE) {
41021
70
    ZVAL_TRUE(EX_VAR(opline->result.var));
41022
463
  } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
41023
    /* The result and op1 can be the same cv zval */
41024
84
    const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
41025
84
    ZVAL_FALSE(EX_VAR(opline->result.var));
41026
84
    if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
41027
8
      SAVE_OPLINE();
41028
8
      ZVAL_UNDEFINED_OP1();
41029
8
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41030
8
    }
41031
379
  } else {
41032
379
    SAVE_OPLINE();
41033
379
    ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
41034
41035
379
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41036
379
  }
41037
146
  ZEND_VM_NEXT_OPCODE();
41038
146
}
41039
41040
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41041
451
{
41042
451
  USE_OPLINE
41043
451
  zval *obj;
41044
451
  zend_object *zobj;
41045
451
  zend_class_entry *ce, *scope;
41046
451
  zend_function *clone;
41047
451
  zend_object_clone_obj_t clone_call;
41048
41049
451
  SAVE_OPLINE();
41050
451
  obj = EX_VAR(opline->op1.var);
41051
41052
  /* ZEND_CLONE also exists as the clone() function and both implementations must be kept in sync.
41053
   * The OPcode intentionally does not support a clone-with property list to keep it simple. */
41054
41055
451
  do {
41056
451
    if (IS_CV == IS_CONST ||
41057
451
        (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
41058
15
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
41059
0
        obj = Z_REFVAL_P(obj);
41060
0
        if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
41061
0
          break;
41062
0
        }
41063
0
      }
41064
15
      ZVAL_UNDEF(EX_VAR(opline->result.var));
41065
15
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
41066
15
        ZVAL_UNDEFINED_OP1();
41067
15
        if (UNEXPECTED(EG(exception) != NULL)) {
41068
0
          HANDLE_EXCEPTION();
41069
0
        }
41070
15
      }
41071
15
      zend_type_error("clone(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(obj));
41072
41073
15
      HANDLE_EXCEPTION();
41074
15
    }
41075
451
  } while (0);
41076
41077
436
  zobj = Z_OBJ_P(obj);
41078
436
  ce = zobj->ce;
41079
436
  clone = ce->clone;
41080
436
  clone_call = zobj->handlers->clone_obj;
41081
436
  if (UNEXPECTED(clone_call == NULL)) {
41082
5
    zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
41083
41084
5
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41085
5
    HANDLE_EXCEPTION();
41086
5
  }
41087
41088
431
  if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
41089
5
    scope = EX(func)->op_array.scope;
41090
5
    ZEND_ASSERT(!(clone->common.fn_flags & ZEND_ACC_PUBLIC));
41091
5
    if (!zend_check_method_accessible(clone, scope)) {
41092
0
      zend_bad_method_call(clone, clone->common.function_name, scope);
41093
41094
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
41095
0
      HANDLE_EXCEPTION();
41096
0
    }
41097
5
  }
41098
41099
431
  ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
41100
41101
431
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41102
431
}
41103
41104
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41105
4.68k
{
41106
4.68k
  USE_OPLINE
41107
4.68k
  zval *expr;
41108
4.68k
  zval *result = EX_VAR(opline->result.var);
41109
41110
4.68k
  SAVE_OPLINE();
41111
4.68k
  expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41112
41113
4.68k
  switch (opline->extended_value) {
41114
1.88k
    case IS_LONG:
41115
1.88k
      ZVAL_LONG(result, zval_get_long(expr));
41116
1.88k
      break;
41117
123
    case IS_DOUBLE:
41118
123
      ZVAL_DOUBLE(result, zval_get_double(expr));
41119
123
      break;
41120
1.82k
    case IS_STRING:
41121
1.82k
      ZVAL_STR(result, zval_get_string(expr));
41122
1.82k
      break;
41123
846
    default:
41124
846
      ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
41125
846
      if (IS_CV & (IS_VAR|IS_CV)) {
41126
846
        ZVAL_DEREF(expr);
41127
846
      }
41128
      /* If value is already of correct type, return it directly */
41129
846
      if (Z_TYPE_P(expr) == opline->extended_value) {
41130
582
        ZVAL_COPY_VALUE(result, expr);
41131
582
        if (IS_CV == IS_CONST) {
41132
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41133
582
        } else if (IS_CV != IS_TMP_VAR) {
41134
582
          if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41135
582
        }
41136
41137
582
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41138
582
      }
41139
41140
264
      if (opline->extended_value == IS_ARRAY) {
41141
210
        zend_cast_zval_to_array(result, expr, IS_CV);
41142
210
      } else {
41143
54
        ZEND_ASSERT(opline->extended_value == IS_OBJECT);
41144
54
        zend_cast_zval_to_object(result, expr, IS_CV);
41145
54
      }
41146
4.68k
  }
41147
41148
4.10k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41149
4.10k
}
41150
41151
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41152
1.44k
{
41153
1.44k
  USE_OPLINE
41154
1.44k
  zend_op_array *new_op_array;
41155
1.44k
  zval *inc_filename;
41156
41157
1.44k
  SAVE_OPLINE();
41158
1.44k
  inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41159
1.44k
  new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
41160
1.44k
  if (UNEXPECTED(EG(exception) != NULL)) {
41161
41162
930
    if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
41163
0
      destroy_op_array(new_op_array);
41164
0
      efree_size(new_op_array, sizeof(zend_op_array));
41165
0
    }
41166
930
    UNDEF_RESULT();
41167
930
    HANDLE_EXCEPTION();
41168
930
  } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
41169
4
    if (RETURN_VALUE_USED(opline)) {
41170
0
      ZVAL_TRUE(EX_VAR(opline->result.var));
41171
0
    }
41172
506
  } else if (UNEXPECTED(new_op_array == NULL)) {
41173
33
    if (RETURN_VALUE_USED(opline)) {
41174
0
      ZVAL_FALSE(EX_VAR(opline->result.var));
41175
0
    }
41176
473
  } else if (new_op_array->last == 1
41177
473
      && new_op_array->opcodes[0].opcode == ZEND_RETURN
41178
473
      && new_op_array->opcodes[0].op1_type == IS_CONST
41179
473
      && EXPECTED(zend_execute_ex == execute_ex)) {
41180
9
    if (RETURN_VALUE_USED(opline)) {
41181
0
      const zend_op *op = new_op_array->opcodes;
41182
41183
0
      ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
41184
0
    }
41185
9
    zend_destroy_static_vars(new_op_array);
41186
9
    destroy_op_array(new_op_array);
41187
9
    efree_size(new_op_array, sizeof(zend_op_array));
41188
464
  } else {
41189
464
    zval *return_value = NULL;
41190
464
    zend_execute_data *call;
41191
464
    if (RETURN_VALUE_USED(opline)) {
41192
428
      return_value = EX_VAR(opline->result.var);
41193
428
    }
41194
41195
464
    new_op_array->scope = EX(func)->op_array.scope;
41196
41197
464
    call = zend_vm_stack_push_call_frame(
41198
464
      (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
41199
464
      (zend_function*)new_op_array, 0,
41200
464
      Z_PTR(EX(This)));
41201
41202
464
    if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
41203
34
      call->symbol_table = EX(symbol_table);
41204
430
    } else {
41205
430
      call->symbol_table = zend_rebuild_symbol_table();
41206
430
    }
41207
41208
464
    call->prev_execute_data = execute_data;
41209
464
    i_init_code_execute_data(call, new_op_array, return_value);
41210
41211
464
    if (EXPECTED(zend_execute_ex == execute_ex)) {
41212
41213
262
      ZEND_VM_ENTER();
41214
262
    } else {
41215
202
      ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
41216
202
      zend_execute_ex(call);
41217
202
      zend_vm_stack_free_call_frame(call);
41218
202
    }
41219
41220
202
    zend_destroy_static_vars(new_op_array);
41221
202
    destroy_op_array(new_op_array);
41222
202
    efree_size(new_op_array, sizeof(zend_op_array));
41223
202
    if (UNEXPECTED(EG(exception) != NULL)) {
41224
109
      zend_rethrow_exception(execute_data);
41225
41226
109
      UNDEF_RESULT();
41227
109
      HANDLE_EXCEPTION();
41228
109
    }
41229
202
  }
41230
41231
139
  ZEND_VM_NEXT_OPCODE();
41232
139
}
41233
41234
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41235
18.6k
{
41236
18.6k
  USE_OPLINE
41237
18.6k
  zval *array_ptr, *result;
41238
41239
18.6k
  SAVE_OPLINE();
41240
41241
18.6k
  array_ptr = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41242
18.6k
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
41243
16.5k
    result = EX_VAR(opline->result.var);
41244
16.5k
    ZVAL_COPY_VALUE(result, array_ptr);
41245
16.5k
    if (IS_CV != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
41246
4.03k
      Z_ADDREF_P(array_ptr);
41247
4.03k
    }
41248
16.5k
    Z_FE_POS_P(result) = 0;
41249
41250
16.5k
    ZEND_VM_NEXT_OPCODE();
41251
16.5k
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
41252
920
    zend_object *zobj = Z_OBJ_P(array_ptr);
41253
920
    if (!zobj->ce->get_iterator) {
41254
140
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
41255
44
        zobj = zend_lazy_object_init(zobj);
41256
44
        if (UNEXPECTED(EG(exception))) {
41257
11
          UNDEF_RESULT();
41258
41259
11
          HANDLE_EXCEPTION();
41260
11
        }
41261
44
      }
41262
129
      HashTable *properties = zobj->properties;
41263
129
      if (properties) {
41264
85
        if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
41265
8
          if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
41266
8
            GC_DELREF(properties);
41267
8
          }
41268
8
          properties = zobj->properties = zend_array_dup(properties);
41269
8
        }
41270
85
      } else {
41271
44
        properties = zobj->handlers->get_properties(zobj);
41272
44
      }
41273
41274
129
      result = EX_VAR(opline->result.var);
41275
129
      ZVAL_COPY_VALUE(result, array_ptr);
41276
129
      if (IS_CV != IS_TMP_VAR) {
41277
129
        Z_ADDREF_P(array_ptr);
41278
129
      }
41279
41280
129
      if (zend_hash_num_elements(properties) == 0) {
41281
9
        Z_FE_ITER_P(result) = (uint32_t) -1;
41282
41283
9
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41284
9
      }
41285
41286
120
      Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
41287
41288
120
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41289
780
    } else {
41290
780
      bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
41291
41292
780
      if (UNEXPECTED(EG(exception))) {
41293
92
        HANDLE_EXCEPTION();
41294
688
      } else if (is_empty) {
41295
43
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41296
645
      } else {
41297
645
        ZEND_VM_NEXT_OPCODE();
41298
645
      }
41299
780
    }
41300
1.21k
  } else {
41301
1.21k
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
41302
1.21k
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41303
1.21k
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
41304
41305
1.21k
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41306
1.21k
  }
41307
18.6k
}
41308
41309
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41310
1.40k
{
41311
1.40k
  USE_OPLINE
41312
1.40k
  zval *array_ptr, *array_ref;
41313
41314
1.40k
  SAVE_OPLINE();
41315
41316
1.40k
  if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41317
1.40k
    array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41318
1.40k
    if (Z_ISREF_P(array_ref)) {
41319
278
      array_ptr = Z_REFVAL_P(array_ref);
41320
278
    }
41321
1.40k
  } else {
41322
0
    array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41323
0
  }
41324
41325
1.40k
  if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
41326
804
    if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41327
804
      if (array_ptr == array_ref) {
41328
549
        ZVAL_NEW_REF(array_ref, array_ref);
41329
549
        array_ptr = Z_REFVAL_P(array_ref);
41330
549
      }
41331
804
      Z_ADDREF_P(array_ref);
41332
804
      ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
41333
804
    } else {
41334
0
      array_ref = EX_VAR(opline->result.var);
41335
0
      ZVAL_NEW_REF(array_ref, array_ptr);
41336
0
      array_ptr = Z_REFVAL_P(array_ref);
41337
0
    }
41338
804
    if (IS_CV == IS_CONST) {
41339
0
      ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
41340
804
    } else {
41341
804
      SEPARATE_ARRAY(array_ptr);
41342
804
    }
41343
804
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
41344
41345
804
    ZEND_VM_NEXT_OPCODE();
41346
804
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
41347
238
    if (!Z_OBJCE_P(array_ptr)->get_iterator) {
41348
54
      zend_object *zobj = Z_OBJ_P(array_ptr);
41349
54
      HashTable *properties;
41350
54
      if (UNEXPECTED(zend_object_is_lazy(zobj))) {
41351
32
        zobj = zend_lazy_object_init(zobj);
41352
32
        if (UNEXPECTED(EG(exception))) {
41353
8
          UNDEF_RESULT();
41354
41355
8
          HANDLE_EXCEPTION();
41356
8
        }
41357
32
      }
41358
46
      if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41359
46
        if (array_ptr == array_ref) {
41360
28
          ZVAL_NEW_REF(array_ref, array_ref);
41361
28
          array_ptr = Z_REFVAL_P(array_ref);
41362
28
        }
41363
46
        Z_ADDREF_P(array_ref);
41364
46
        ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
41365
46
      } else {
41366
0
        array_ptr = EX_VAR(opline->result.var);
41367
0
        ZVAL_COPY_VALUE(array_ptr, array_ref);
41368
0
      }
41369
46
      if (Z_OBJ_P(array_ptr)->properties
41370
46
       && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
41371
0
        if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
41372
0
          GC_DELREF(Z_OBJ_P(array_ptr)->properties);
41373
0
        }
41374
0
        Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
41375
0
      }
41376
41377
46
      properties = Z_OBJPROP_P(array_ptr);
41378
46
      if (zend_hash_num_elements(properties) == 0) {
41379
0
        Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
41380
41381
0
        ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41382
0
      }
41383
41384
46
      Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
41385
41386
46
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41387
184
    } else {
41388
184
      bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
41389
41390
184
      if (UNEXPECTED(EG(exception))) {
41391
13
        HANDLE_EXCEPTION();
41392
171
      } else if (is_empty) {
41393
8
        ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41394
163
      } else {
41395
163
        ZEND_VM_NEXT_OPCODE();
41396
163
      }
41397
184
    }
41398
359
  } else {
41399
359
    zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
41400
359
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41401
359
    Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
41402
41403
359
    ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41404
359
  }
41405
1.40k
}
41406
41407
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41408
278
{
41409
278
  USE_OPLINE
41410
278
  zval *value;
41411
278
  zend_reference *ref = NULL;
41412
278
  bool ret;
41413
41414
278
  SAVE_OPLINE();
41415
278
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41416
41417
278
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) {
41418
0
    if (IS_CV == IS_VAR) {
41419
0
      ref = Z_REF_P(value);
41420
0
    }
41421
0
    value = Z_REFVAL_P(value);
41422
0
  }
41423
41424
278
  ret = i_zend_is_true(value);
41425
41426
278
  if (UNEXPECTED(EG(exception))) {
41427
41428
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41429
0
    HANDLE_EXCEPTION();
41430
0
  }
41431
41432
278
  if (ret) {
41433
180
    zval *result = EX_VAR(opline->result.var);
41434
41435
180
    ZVAL_COPY_VALUE(result, value);
41436
180
    if (IS_CV == IS_CONST) {
41437
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41438
180
    } else if (IS_CV == IS_CV) {
41439
180
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41440
180
    } else if (IS_CV == IS_VAR && ref) {
41441
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41442
0
        efree_size(ref, sizeof(zend_reference));
41443
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
41444
0
        Z_ADDREF_P(result);
41445
0
      }
41446
0
    }
41447
180
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41448
180
  }
41449
41450
98
  ZEND_VM_NEXT_OPCODE();
41451
98
}
41452
41453
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41454
158
{
41455
158
  USE_OPLINE
41456
158
  zval *value;
41457
158
  zend_reference *ref = NULL;
41458
41459
158
  SAVE_OPLINE();
41460
158
  value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
41461
41462
158
  if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
41463
0
    if (IS_CV & IS_VAR) {
41464
0
      ref = Z_REF_P(value);
41465
0
    }
41466
0
    value = Z_REFVAL_P(value);
41467
0
  }
41468
41469
158
  if (Z_TYPE_P(value) > IS_NULL) {
41470
55
    zval *result = EX_VAR(opline->result.var);
41471
55
    ZVAL_COPY_VALUE(result, value);
41472
55
    if (IS_CV == IS_CONST) {
41473
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41474
55
    } else if (IS_CV == IS_CV) {
41475
55
      if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41476
55
    } else if ((IS_CV & IS_VAR) && ref) {
41477
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41478
0
        efree_size(ref, sizeof(zend_reference));
41479
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
41480
0
        Z_ADDREF_P(result);
41481
0
      }
41482
0
    }
41483
55
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41484
55
  }
41485
41486
103
  if ((IS_CV & IS_VAR) && ref) {
41487
0
    if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41488
0
      efree_size(ref, sizeof(zend_reference));
41489
0
    }
41490
0
  }
41491
103
  ZEND_VM_NEXT_OPCODE();
41492
103
}
41493
41494
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41495
59.7k
{
41496
59.7k
  USE_OPLINE
41497
59.7k
  zval *val, *result;
41498
41499
59.7k
  val = EX_VAR(opline->op1.var);
41500
41501
59.7k
  if (Z_TYPE_P(val) > IS_NULL) {
41502
310
    do {
41503
310
      if ((IS_CV == IS_CV || IS_CV == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
41504
17
        val = Z_REFVAL_P(val);
41505
17
        if (Z_TYPE_P(val) <= IS_NULL) {
41506
41507
12
          break;
41508
12
        }
41509
17
      }
41510
298
      ZEND_VM_NEXT_OPCODE();
41511
298
    } while (0);
41512
310
  }
41513
41514
59.4k
  result = EX_VAR(opline->result.var);
41515
59.4k
  uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
41516
59.4k
  if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
41517
59.3k
    ZVAL_NULL(result);
41518
59.3k
    if (IS_CV == IS_CV
41519
59.3k
      && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
41520
59.3k
      && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
41521
59.3k
    ) {
41522
59.0k
      SAVE_OPLINE();
41523
59.0k
      ZVAL_UNDEFINED_OP1();
41524
59.0k
      if (UNEXPECTED(EG(exception) != NULL)) {
41525
0
        HANDLE_EXCEPTION();
41526
0
      }
41527
59.0k
    }
41528
59.3k
  } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
41529
37
    ZVAL_FALSE(result);
41530
37
  } else {
41531
37
    ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
41532
37
    ZVAL_TRUE(result);
41533
37
  }
41534
41535
59.4k
  ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41536
59.4k
}
41537
41538
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41539
14.4k
{
41540
14.4k
  USE_OPLINE
41541
14.4k
  zval *value;
41542
14.4k
  zval *result = EX_VAR(opline->result.var);
41543
41544
14.4k
  value = EX_VAR(opline->op1.var);
41545
14.4k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41546
7.49k
    SAVE_OPLINE();
41547
7.49k
    ZVAL_UNDEFINED_OP1();
41548
7.49k
    ZVAL_NULL(result);
41549
7.49k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41550
7.49k
  }
41551
41552
6.95k
  if (IS_CV == IS_CV) {
41553
6.95k
    ZVAL_COPY_DEREF(result, value);
41554
6.95k
  } else if (IS_CV == IS_VAR) {
41555
0
    if (UNEXPECTED(Z_ISREF_P(value))) {
41556
0
      ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
41557
0
      if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
41558
0
        efree_size(Z_REF_P(value), sizeof(zend_reference));
41559
0
      } else if (Z_OPT_REFCOUNTED_P(result)) {
41560
0
        Z_ADDREF_P(result);
41561
0
      }
41562
0
    } else {
41563
0
      ZVAL_COPY_VALUE(result, value);
41564
0
    }
41565
0
  } else {
41566
0
    ZVAL_COPY_VALUE(result, value);
41567
0
    if (IS_CV == IS_CONST) {
41568
0
      if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
41569
0
        Z_ADDREF_P(result);
41570
0
      }
41571
0
    }
41572
0
  }
41573
6.95k
  ZEND_VM_NEXT_OPCODE();
41574
6.95k
}
41575
41576
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41577
444
{
41578
444
  USE_OPLINE
41579
444
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
41580
444
  zval *val;
41581
41582
444
  SAVE_OPLINE();
41583
444
  val = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41584
41585
444
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
41586
0
    zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
41587
41588
0
    UNDEF_RESULT();
41589
0
    HANDLE_EXCEPTION();
41590
0
  }
41591
41592
444
yield_from_try_again:
41593
444
  if (Z_TYPE_P(val) == IS_ARRAY) {
41594
5
    ZVAL_COPY_VALUE(&generator->values, val);
41595
5
    if (Z_OPT_REFCOUNTED_P(val)) {
41596
0
      Z_ADDREF_P(val);
41597
0
    }
41598
5
    Z_FE_POS(generator->values) = 0;
41599
41600
439
  } else if (IS_CV != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
41601
417
    zend_class_entry *ce = Z_OBJCE_P(val);
41602
417
    if (ce == zend_ce_generator) {
41603
402
      zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
41604
41605
402
      Z_ADDREF_P(val);
41606
41607
402
      if (UNEXPECTED(new_gen->execute_data == NULL)) {
41608
8
        zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
41609
8
        zval_ptr_dtor(val);
41610
8
        UNDEF_RESULT();
41611
8
        HANDLE_EXCEPTION();
41612
394
      } else if (Z_ISUNDEF(new_gen->retval)) {
41613
394
        if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
41614
0
          zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
41615
0
          zval_ptr_dtor(val);
41616
0
          UNDEF_RESULT();
41617
0
          HANDLE_EXCEPTION();
41618
394
        } else {
41619
394
          zend_generator_yield_from(generator, new_gen);
41620
394
        }
41621
394
      } else {
41622
0
        if (RETURN_VALUE_USED(opline)) {
41623
0
          ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
41624
0
        }
41625
0
        ZEND_VM_NEXT_OPCODE();
41626
0
      }
41627
402
    } else {
41628
15
      zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
41629
41630
15
      if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
41631
0
        if (!EG(exception)) {
41632
0
          zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
41633
0
        }
41634
0
        UNDEF_RESULT();
41635
0
        HANDLE_EXCEPTION();
41636
0
      }
41637
41638
15
      iter->index = 0;
41639
15
      if (iter->funcs->rewind) {
41640
15
        iter->funcs->rewind(iter);
41641
15
        if (UNEXPECTED(EG(exception) != NULL)) {
41642
5
          OBJ_RELEASE(&iter->std);
41643
5
          UNDEF_RESULT();
41644
5
          HANDLE_EXCEPTION();
41645
5
        }
41646
15
      }
41647
41648
10
      ZVAL_OBJ(&generator->values, &iter->std);
41649
10
    }
41650
417
  } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
41651
0
    val = Z_REFVAL_P(val);
41652
0
    goto yield_from_try_again;
41653
22
  } else {
41654
22
    zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
41655
41656
22
    UNDEF_RESULT();
41657
22
    HANDLE_EXCEPTION();
41658
22
  }
41659
41660
  /* This is the default return value
41661
   * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
41662
409
  if (RETURN_VALUE_USED(opline)) {
41663
409
    ZVAL_NULL(EX_VAR(opline->result.var));
41664
409
  }
41665
41666
  /* This generator has no send target (though the generator we delegate to might have one) */
41667
409
  generator->send_target = NULL;
41668
41669
  /* The GOTO VM uses a local opline variable. We need to set the opline
41670
   * variable in execute_data so we don't resume at an old position. */
41671
409
  SAVE_OPLINE();
41672
41673
409
  ZEND_VM_RETURN();
41674
444
}
41675
41676
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41677
359
{
41678
359
  USE_OPLINE
41679
359
  zval *value;
41680
41681
359
  value = EX_VAR(opline->op1.var);
41682
359
  if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
41683
315
    ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
41684
315
    if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41685
0
      zval_ptr_dtor_str(value);
41686
0
    }
41687
315
    ZEND_VM_NEXT_OPCODE();
41688
315
  } else {
41689
44
    bool strict;
41690
41691
44
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
41692
0
      value = Z_REFVAL_P(value);
41693
0
      if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
41694
0
        ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
41695
41696
0
        ZEND_VM_NEXT_OPCODE();
41697
0
      }
41698
0
    }
41699
41700
44
    SAVE_OPLINE();
41701
44
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41702
6
      value = ZVAL_UNDEFINED_OP1();
41703
6
    }
41704
44
    strict = EX_USES_STRICT_TYPES();
41705
44
    do {
41706
44
      if (EXPECTED(!strict)) {
41707
44
        zend_string *str;
41708
44
        zval tmp;
41709
41710
44
        if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
41711
11
          zend_error(E_DEPRECATED,
41712
11
            "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
41713
11
          ZVAL_LONG(EX_VAR(opline->result.var), 0);
41714
11
          if (UNEXPECTED(EG(exception))) {
41715
0
            HANDLE_EXCEPTION();
41716
0
          }
41717
11
          break;
41718
11
        }
41719
41720
33
        ZVAL_COPY(&tmp, value);
41721
33
        if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
41722
17
          ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
41723
17
          zval_ptr_dtor(&tmp);
41724
17
          break;
41725
17
        }
41726
16
        zval_ptr_dtor(&tmp);
41727
16
      }
41728
16
      if (!EG(exception)) {
41729
3
        zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
41730
3
      }
41731
16
      ZVAL_UNDEF(EX_VAR(opline->result.var));
41732
16
    } while (0);
41733
44
  }
41734
41735
44
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41736
44
}
41737
41738
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41739
3.90k
{
41740
3.90k
  USE_OPLINE
41741
3.90k
  zval *value;
41742
3.90k
  int result = 0;
41743
41744
3.90k
  value = EX_VAR(opline->op1.var);
41745
3.90k
  if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
41746
1.31k
type_check_resource:
41747
1.31k
    if (opline->extended_value != MAY_BE_RESOURCE
41748
1.31k
     || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
41749
1.31k
      result = 1;
41750
1.31k
    }
41751
2.89k
  } else if ((IS_CV & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
41752
314
    value = Z_REFVAL_P(value);
41753
314
    if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
41754
299
      goto type_check_resource;
41755
299
    }
41756
2.57k
  } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41757
704
    result = ((1 << IS_NULL) & opline->extended_value) != 0;
41758
704
    SAVE_OPLINE();
41759
704
    ZVAL_UNDEFINED_OP1();
41760
704
    if (UNEXPECTED(EG(exception))) {
41761
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
41762
0
      HANDLE_EXCEPTION();
41763
0
    }
41764
704
  }
41765
3.90k
  if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41766
0
    SAVE_OPLINE();
41767
41768
0
    ZEND_VM_SMART_BRANCH(result, 1);
41769
3.90k
  } else {
41770
3.90k
    ZEND_VM_SMART_BRANCH(result, 0);
41771
3.90k
  }
41772
3.90k
}
41773
41774
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41775
856
{
41776
856
  uint32_t fetch_type;
41777
856
  zend_class_entry *called_scope, *scope;
41778
856
  USE_OPLINE
41779
41780
856
  if (IS_CV != IS_UNUSED) {
41781
856
    SAVE_OPLINE();
41782
856
    zval *op = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41783
856
    if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
41784
27
      ZVAL_DEREF(op);
41785
27
      if (Z_TYPE_P(op) != IS_OBJECT) {
41786
13
        zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
41787
13
        ZVAL_UNDEF(EX_VAR(opline->result.var));
41788
41789
13
        HANDLE_EXCEPTION();
41790
13
      }
41791
27
    }
41792
41793
843
    ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
41794
41795
843
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41796
843
  }
41797
41798
0
  fetch_type = opline->op1.num;
41799
0
  scope = EX(func)->op_array.scope;
41800
0
  if (UNEXPECTED(scope == NULL)) {
41801
0
    SAVE_OPLINE();
41802
0
    zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
41803
0
      fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
41804
0
      fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
41805
0
    ZVAL_UNDEF(EX_VAR(opline->result.var));
41806
0
    HANDLE_EXCEPTION();
41807
0
  }
41808
41809
0
  switch (fetch_type) {
41810
0
    case ZEND_FETCH_CLASS_SELF:
41811
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
41812
0
      break;
41813
0
    case ZEND_FETCH_CLASS_PARENT:
41814
0
      if (UNEXPECTED(scope->parent == NULL)) {
41815
0
        SAVE_OPLINE();
41816
0
        zend_throw_error(NULL,
41817
0
          "Cannot use \"parent\" when current class scope has no parent");
41818
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
41819
0
        HANDLE_EXCEPTION();
41820
0
      }
41821
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
41822
0
      break;
41823
0
    case ZEND_FETCH_CLASS_STATIC:
41824
0
      if (Z_TYPE(EX(This)) == IS_OBJECT) {
41825
0
        called_scope = Z_OBJCE(EX(This));
41826
0
      } else {
41827
0
        called_scope = Z_CE(EX(This));
41828
0
      }
41829
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
41830
0
      break;
41831
0
    EMPTY_SWITCH_DEFAULT_CASE()
41832
0
  }
41833
0
  ZEND_VM_NEXT_OPCODE();
41834
0
}
41835
41836
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41837
7.33k
{
41838
7.33k
  USE_OPLINE
41839
7.33k
  HashTable *ht;
41840
7.33k
  zval *value;
41841
7.33k
  zval *variable_ptr;
41842
41843
7.33k
  variable_ptr = EX_VAR(opline->op1.var);
41844
41845
7.33k
  SAVE_OPLINE();
41846
41847
7.33k
  ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
41848
7.33k
  if (!ht) {
41849
415
    ht = zend_array_dup(EX(func)->op_array.static_variables);
41850
415
    ZEND_MAP_PTR_SET(EX(func)->op_array.static_variables_ptr, ht);
41851
415
  }
41852
7.33k
  ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
41853
41854
7.33k
  value = (zval*)((char*)ht->arData + (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT|ZEND_BIND_EXPLICIT)));
41855
41856
7.33k
  if (opline->extended_value & ZEND_BIND_REF) {
41857
2.72k
    if (UNEXPECTED(!Z_ISREF_P(value))) {
41858
576
      zend_reference *ref = (zend_reference*)emalloc(sizeof(zend_reference));
41859
576
      GC_SET_REFCOUNT(ref, 2);
41860
576
      GC_TYPE_INFO(ref) = GC_REFERENCE;
41861
576
      if (opline->op2_type == IS_UNUSED) {
41862
347
        ZVAL_COPY_VALUE(&ref->val, value);
41863
347
      } else {
41864
229
        ZEND_ASSERT(!Z_REFCOUNTED_P(value));
41865
229
        ZVAL_COPY(&ref->val, get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R));
41866
229
        FREE_OP(opline->op2_type, opline->op2.var);
41867
229
      }
41868
576
      ref->sources.ptr = NULL;
41869
576
      Z_REF_P(value) = ref;
41870
576
      Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
41871
576
      i_zval_ptr_dtor(variable_ptr);
41872
576
      ZVAL_REF(variable_ptr, ref);
41873
2.15k
    } else {
41874
2.15k
      Z_ADDREF_P(value);
41875
2.15k
      i_zval_ptr_dtor(variable_ptr);
41876
2.15k
      ZVAL_REF(variable_ptr, Z_REF_P(value));
41877
2.15k
      if (opline->op2_type != IS_UNUSED) {
41878
109
        FREE_OP(opline->op2_type, opline->op2.var);
41879
109
      }
41880
2.15k
    }
41881
4.60k
  } else {
41882
4.60k
    i_zval_ptr_dtor(variable_ptr);
41883
4.60k
    ZVAL_COPY(variable_ptr, value);
41884
4.60k
  }
41885
41886
7.33k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41887
7.33k
}
41888
41889
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41890
623
{
41891
623
  USE_OPLINE
41892
623
  HashTable *ht;
41893
623
  zval *value;
41894
623
  zval *variable_ptr;
41895
41896
623
  variable_ptr = EX_VAR(opline->op1.var);
41897
41898
623
  ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
41899
623
  if (!ht) {
41900
314
    ZEND_VM_NEXT_OPCODE();
41901
314
  }
41902
309
  ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
41903
41904
309
  value = (zval*)((char*)ht->arData + opline->extended_value);
41905
309
  if (Z_TYPE_P(value) == IS_NULL) {
41906
104
    ZEND_VM_NEXT_OPCODE();
41907
205
  } else {
41908
205
    SAVE_OPLINE();
41909
205
    zval_ptr_dtor(variable_ptr);
41910
205
    ZEND_ASSERT(Z_TYPE_P(value) == IS_REFERENCE);
41911
205
    Z_ADDREF_P(value);
41912
205
    ZVAL_REF(variable_ptr, Z_REF_P(value));
41913
205
    ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 1);
41914
205
  }
41915
309
}
41916
41917
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)
41918
14.9k
{
41919
14.9k
  USE_OPLINE
41920
14.9k
  zval *var_ptr;
41921
41922
14.9k
  var_ptr = EX_VAR(opline->op1.var);
41923
14.9k
  Z_LVAL_P(var_ptr)++;
41924
14.9k
  if (UNEXPECTED(0)) {
41925
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41926
0
  }
41927
14.9k
  ZEND_VM_NEXT_OPCODE();
41928
14.9k
}
41929
41930
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)
41931
0
{
41932
0
  USE_OPLINE
41933
0
  zval *var_ptr;
41934
41935
0
  var_ptr = EX_VAR(opline->op1.var);
41936
0
  Z_LVAL_P(var_ptr)++;
41937
0
  if (UNEXPECTED(1)) {
41938
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41939
0
  }
41940
0
  ZEND_VM_NEXT_OPCODE();
41941
0
}
41942
41943
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41944
11
{
41945
11
  USE_OPLINE
41946
11
  zval *var_ptr;
41947
41948
11
  var_ptr = EX_VAR(opline->op1.var);
41949
11
  fast_long_increment_function(var_ptr);
41950
11
  if (UNEXPECTED(0)) {
41951
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41952
0
  }
41953
11
  ZEND_VM_NEXT_OPCODE();
41954
11
}
41955
41956
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41957
0
{
41958
0
  USE_OPLINE
41959
0
  zval *var_ptr;
41960
41961
0
  var_ptr = EX_VAR(opline->op1.var);
41962
0
  fast_long_increment_function(var_ptr);
41963
0
  if (UNEXPECTED(1)) {
41964
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41965
0
  }
41966
0
  ZEND_VM_NEXT_OPCODE();
41967
0
}
41968
41969
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)
41970
0
{
41971
0
  USE_OPLINE
41972
0
  zval *var_ptr;
41973
41974
0
  var_ptr = EX_VAR(opline->op1.var);
41975
0
  Z_LVAL_P(var_ptr)--;
41976
0
  if (UNEXPECTED(0)) {
41977
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41978
0
  }
41979
0
  ZEND_VM_NEXT_OPCODE();
41980
0
}
41981
41982
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)
41983
0
{
41984
0
  USE_OPLINE
41985
0
  zval *var_ptr;
41986
41987
0
  var_ptr = EX_VAR(opline->op1.var);
41988
0
  Z_LVAL_P(var_ptr)--;
41989
0
  if (UNEXPECTED(1)) {
41990
0
    ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41991
0
  }
41992
0
  ZEND_VM_NEXT_OPCODE();
41993
0
}
41994
41995
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41996
446
{
41997
446
  USE_OPLINE
41998
446
  zval *var_ptr;
41999
42000
446
  var_ptr = EX_VAR(opline->op1.var);
42001
446
  fast_long_decrement_function(var_ptr);
42002
446
  if (UNEXPECTED(0)) {
42003
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
42004
0
  }
42005
446
  ZEND_VM_NEXT_OPCODE();
42006
446
}
42007
42008
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42009
0
{
42010
0
  USE_OPLINE
42011
0
  zval *var_ptr;
42012
42013
0
  var_ptr = EX_VAR(opline->op1.var);
42014
0
  fast_long_decrement_function(var_ptr);
42015
0
  if (UNEXPECTED(1)) {
42016
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
42017
0
  }
42018
0
  ZEND_VM_NEXT_OPCODE();
42019
0
}
42020
42021
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42022
300
{
42023
300
  USE_OPLINE
42024
300
  zval *var_ptr;
42025
42026
300
  var_ptr = EX_VAR(opline->op1.var);
42027
300
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
42028
300
  Z_LVAL_P(var_ptr)++;
42029
300
  ZEND_VM_NEXT_OPCODE();
42030
300
}
42031
42032
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42033
8
{
42034
8
  USE_OPLINE
42035
8
  zval *var_ptr;
42036
42037
8
  var_ptr = EX_VAR(opline->op1.var);
42038
8
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
42039
8
  fast_long_increment_function(var_ptr);
42040
8
  ZEND_VM_NEXT_OPCODE();
42041
8
}
42042
42043
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42044
1.00k
{
42045
1.00k
  USE_OPLINE
42046
1.00k
  zval *var_ptr;
42047
42048
1.00k
  var_ptr = EX_VAR(opline->op1.var);
42049
1.00k
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
42050
1.00k
  Z_LVAL_P(var_ptr)--;
42051
1.00k
  ZEND_VM_NEXT_OPCODE();
42052
1.00k
}
42053
42054
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42055
1.94k
{
42056
1.94k
  USE_OPLINE
42057
1.94k
  zval *var_ptr;
42058
42059
1.94k
  var_ptr = EX_VAR(opline->op1.var);
42060
1.94k
  ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
42061
1.94k
  fast_long_decrement_function(var_ptr);
42062
1.94k
  ZEND_VM_NEXT_OPCODE();
42063
1.94k
}
42064
42065
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42066
19.7k
{
42067
19.7k
  USE_OPLINE
42068
19.7k
  zval *varptr, *arg;
42069
42070
19.7k
  varptr = EX_VAR(opline->op1.var);
42071
19.7k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
42072
42073
19.7k
  if (IS_CV == IS_CV) {
42074
19.7k
    ZVAL_COPY(arg, varptr);
42075
19.7k
  } else /* if (IS_CV == IS_VAR) */ {
42076
0
    ZVAL_COPY_VALUE(arg, varptr);
42077
0
  }
42078
42079
19.7k
  ZEND_VM_NEXT_OPCODE();
42080
19.7k
}
42081
42082
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42083
5.78k
{
42084
5.78k
  USE_OPLINE
42085
5.78k
  zval *op1, *op2;
42086
42087
5.78k
  SAVE_OPLINE();
42088
5.78k
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42089
5.78k
  op2 = RT_CONSTANT(opline, opline->op2);
42090
5.78k
  div_function(EX_VAR(opline->result.var), op1, op2);
42091
42092
42093
5.78k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42094
5.78k
}
42095
42096
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42097
0
{
42098
0
  USE_OPLINE
42099
0
  zval *op1, *op2;
42100
42101
0
  SAVE_OPLINE();
42102
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42103
0
  op2 = RT_CONSTANT(opline, opline->op2);
42104
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
42105
42106
42107
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42108
0
}
42109
42110
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42111
2.49k
{
42112
2.49k
  USE_OPLINE
42113
2.49k
  zval *op1, *op2;
42114
42115
2.49k
  op1 = EX_VAR(opline->op1.var);
42116
2.49k
  op2 = RT_CONSTANT(opline, opline->op2);
42117
42118
2.49k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
42119
2.49k
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
42120
1.76k
    zend_string *op1_str = Z_STR_P(op1);
42121
1.76k
    zend_string *op2_str = Z_STR_P(op2);
42122
1.76k
    zend_string *str;
42123
1.76k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
42124
42125
1.76k
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
42126
1
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
42127
1
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
42128
1
      } else {
42129
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
42130
0
      }
42131
1
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42132
0
        zend_string_release_ex(op1_str, 0);
42133
0
      }
42134
1.76k
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
42135
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
42136
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
42137
0
      } else {
42138
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
42139
0
      }
42140
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42141
0
        zend_string_release_ex(op2_str, 0);
42142
0
      }
42143
1.76k
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
42144
1.76k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
42145
0
      size_t len = ZSTR_LEN(op1_str);
42146
42147
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
42148
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
42149
0
      }
42150
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
42151
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
42152
0
      GC_ADD_FLAGS(str, flags);
42153
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
42154
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42155
0
        zend_string_release_ex(op2_str, 0);
42156
0
      }
42157
1.76k
    } else {
42158
1.76k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
42159
1.76k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
42160
1.76k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
42161
1.76k
      GC_ADD_FLAGS(str, flags);
42162
1.76k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
42163
1.76k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42164
0
        zend_string_release_ex(op1_str, 0);
42165
0
      }
42166
1.76k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42167
0
        zend_string_release_ex(op2_str, 0);
42168
0
      }
42169
1.76k
    }
42170
1.76k
    ZEND_VM_NEXT_OPCODE();
42171
1.76k
  } else {
42172
730
    SAVE_OPLINE();
42173
42174
730
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
42175
246
      op1 = ZVAL_UNDEFINED_OP1();
42176
246
    }
42177
730
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
42178
0
      op2 = ZVAL_UNDEFINED_OP2();
42179
0
    }
42180
730
    concat_function(EX_VAR(opline->result.var), op1, op2);
42181
42182
42183
730
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42184
730
  }
42185
2.49k
}
42186
42187
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42188
1.57k
{
42189
1.57k
  USE_OPLINE
42190
1.57k
  zval *op1, *op2;
42191
1.57k
  bool result;
42192
42193
1.57k
  SAVE_OPLINE();
42194
1.57k
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42195
1.57k
  op2 = RT_CONSTANT(opline, opline->op2);
42196
1.57k
  result = fast_is_identical_function(op1, op2);
42197
42198
42199
1.57k
  ZEND_VM_SMART_BRANCH(result, 1);
42200
1.57k
}
42201
42202
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42203
612
{
42204
612
  USE_OPLINE
42205
612
  zval *op1, *op2;
42206
612
  bool result;
42207
42208
612
  SAVE_OPLINE();
42209
612
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42210
612
  op2 = RT_CONSTANT(opline, opline->op2);
42211
612
  result = fast_is_not_identical_function(op1, op2);
42212
42213
42214
612
  ZEND_VM_SMART_BRANCH(result, 1);
42215
612
}
42216
42217
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42218
708
{
42219
708
  USE_OPLINE
42220
708
  zval *op1, *op2;
42221
708
  double d1, d2;
42222
42223
708
  op1 = EX_VAR(opline->op1.var);
42224
708
  op2 = RT_CONSTANT(opline, opline->op2);
42225
708
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42226
    /* pass */
42227
708
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42228
258
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42229
258
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42230
284
is_equal_true:
42231
284
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
42232
284
      } else {
42233
43
is_equal_false:
42234
43
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
42235
43
      }
42236
258
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42237
0
      d1 = (double)Z_LVAL_P(op1);
42238
0
      d2 = Z_DVAL_P(op2);
42239
0
      goto is_equal_double;
42240
0
    }
42241
450
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42242
58
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42243
0
      d1 = Z_DVAL_P(op1);
42244
0
      d2 = Z_DVAL_P(op2);
42245
37
is_equal_double:
42246
37
      if (d1 == d2) {
42247
37
        goto is_equal_true;
42248
37
      } else {
42249
0
        goto is_equal_false;
42250
0
      }
42251
58
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42252
37
      d1 = Z_DVAL_P(op1);
42253
37
      d2 = (double)Z_LVAL_P(op2);
42254
37
      goto is_equal_double;
42255
37
    }
42256
392
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42257
125
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42258
32
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42259
32
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42260
0
        zval_ptr_dtor_str(op1);
42261
0
      }
42262
32
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42263
0
        zval_ptr_dtor_str(op2);
42264
0
      }
42265
32
      if (result) {
42266
0
        goto is_equal_true;
42267
32
      } else {
42268
32
        goto is_equal_false;
42269
32
      }
42270
32
    }
42271
125
  }
42272
708
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42273
708
}
42274
42275
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42276
214k
{
42277
214k
  USE_OPLINE
42278
214k
  zval *op1, *op2;
42279
214k
  double d1, d2;
42280
42281
214k
  op1 = EX_VAR(opline->op1.var);
42282
214k
  op2 = RT_CONSTANT(opline, opline->op2);
42283
214k
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42284
    /* pass */
42285
214k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42286
1.19k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42287
1.19k
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42288
716
is_equal_true:
42289
716
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
42290
840
      } else {
42291
1.59k
is_equal_false:
42292
1.59k
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
42293
1.59k
      }
42294
1.19k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42295
2
      d1 = (double)Z_LVAL_P(op1);
42296
2
      d2 = Z_DVAL_P(op2);
42297
2
      goto is_equal_double;
42298
2
    }
42299
213k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42300
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42301
0
      d1 = Z_DVAL_P(op1);
42302
0
      d2 = Z_DVAL_P(op2);
42303
2
is_equal_double:
42304
2
      if (d1 == d2) {
42305
0
        goto is_equal_true;
42306
2
      } else {
42307
2
        goto is_equal_false;
42308
2
      }
42309
2
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42310
0
      d1 = Z_DVAL_P(op1);
42311
0
      d2 = (double)Z_LVAL_P(op2);
42312
0
      goto is_equal_double;
42313
0
    }
42314
213k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42315
1.24k
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42316
1.12k
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42317
1.12k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42318
0
        zval_ptr_dtor_str(op1);
42319
0
      }
42320
1.12k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42321
0
        zval_ptr_dtor_str(op2);
42322
0
      }
42323
1.12k
      if (result) {
42324
366
        goto is_equal_true;
42325
756
      } else {
42326
756
        goto is_equal_false;
42327
756
      }
42328
1.12k
    }
42329
1.24k
  }
42330
214k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42331
214k
}
42332
42333
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42334
308
{
42335
308
  USE_OPLINE
42336
308
  zval *op1, *op2;
42337
308
  double d1, d2;
42338
42339
308
  op1 = EX_VAR(opline->op1.var);
42340
308
  op2 = RT_CONSTANT(opline, opline->op2);
42341
308
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42342
    /* pass */
42343
308
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42344
66
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42345
66
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42346
109
is_equal_true:
42347
109
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
42348
109
      } else {
42349
133
is_equal_false:
42350
133
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
42351
133
      }
42352
66
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42353
0
      d1 = (double)Z_LVAL_P(op1);
42354
0
      d2 = Z_DVAL_P(op2);
42355
0
      goto is_equal_double;
42356
0
    }
42357
242
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42358
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42359
0
      d1 = Z_DVAL_P(op1);
42360
0
      d2 = Z_DVAL_P(op2);
42361
0
is_equal_double:
42362
0
      if (d1 == d2) {
42363
0
        goto is_equal_true;
42364
0
      } else {
42365
0
        goto is_equal_false;
42366
0
      }
42367
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42368
0
      d1 = Z_DVAL_P(op1);
42369
0
      d2 = (double)Z_LVAL_P(op2);
42370
0
      goto is_equal_double;
42371
0
    }
42372
242
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42373
176
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42374
176
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42375
176
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42376
0
        zval_ptr_dtor_str(op1);
42377
0
      }
42378
176
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42379
0
        zval_ptr_dtor_str(op2);
42380
0
      }
42381
176
      if (result) {
42382
72
        goto is_equal_true;
42383
104
      } else {
42384
104
        goto is_equal_false;
42385
104
      }
42386
176
    }
42387
176
  }
42388
308
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42389
308
}
42390
42391
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42392
1.59k
{
42393
1.59k
  USE_OPLINE
42394
1.59k
  zval *op1, *op2;
42395
1.59k
  double d1, d2;
42396
42397
1.59k
  op1 = EX_VAR(opline->op1.var);
42398
1.59k
  op2 = RT_CONSTANT(opline, opline->op2);
42399
1.59k
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42400
    /* pass */
42401
1.59k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42402
400
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42403
367
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42404
487
is_not_equal_true:
42405
487
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
42406
487
      } else {
42407
25
is_not_equal_false:
42408
25
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
42409
25
      }
42410
367
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42411
33
      d1 = (double)Z_LVAL_P(op1);
42412
33
      d2 = Z_DVAL_P(op2);
42413
33
      goto is_not_equal_double;
42414
33
    }
42415
1.19k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42416
104
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42417
27
      d1 = Z_DVAL_P(op1);
42418
27
      d2 = Z_DVAL_P(op2);
42419
135
is_not_equal_double:
42420
135
      if (d1 != d2) {
42421
135
        goto is_not_equal_true;
42422
135
      } else {
42423
0
        goto is_not_equal_false;
42424
0
      }
42425
135
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42426
75
      d1 = Z_DVAL_P(op1);
42427
75
      d2 = (double)Z_LVAL_P(op2);
42428
75
      goto is_not_equal_double;
42429
75
    }
42430
1.08k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42431
10
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42432
10
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42433
10
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42434
0
        zval_ptr_dtor_str(op1);
42435
0
      }
42436
10
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42437
0
        zval_ptr_dtor_str(op2);
42438
0
      }
42439
10
      if (!result) {
42440
10
        goto is_not_equal_true;
42441
10
      } else {
42442
0
        goto is_not_equal_false;
42443
0
      }
42444
10
    }
42445
10
  }
42446
1.59k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42447
1.59k
}
42448
42449
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42450
378
{
42451
378
  USE_OPLINE
42452
378
  zval *op1, *op2;
42453
378
  double d1, d2;
42454
42455
378
  op1 = EX_VAR(opline->op1.var);
42456
378
  op2 = RT_CONSTANT(opline, opline->op2);
42457
378
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42458
    /* pass */
42459
378
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42460
65
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42461
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42462
59
is_not_equal_true:
42463
59
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
42464
59
      } else {
42465
257
is_not_equal_false:
42466
257
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
42467
257
      }
42468
65
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42469
27
      d1 = (double)Z_LVAL_P(op1);
42470
27
      d2 = Z_DVAL_P(op2);
42471
27
      goto is_not_equal_double;
42472
27
    }
42473
313
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42474
27
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42475
27
      d1 = Z_DVAL_P(op1);
42476
27
      d2 = Z_DVAL_P(op2);
42477
54
is_not_equal_double:
42478
54
      if (d1 != d2) {
42479
54
        goto is_not_equal_true;
42480
54
      } else {
42481
0
        goto is_not_equal_false;
42482
0
      }
42483
54
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42484
0
      d1 = Z_DVAL_P(op1);
42485
0
      d2 = (double)Z_LVAL_P(op2);
42486
0
      goto is_not_equal_double;
42487
0
    }
42488
286
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42489
262
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42490
262
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42491
262
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42492
0
        zval_ptr_dtor_str(op1);
42493
0
      }
42494
262
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42495
0
        zval_ptr_dtor_str(op2);
42496
0
      }
42497
262
      if (!result) {
42498
5
        goto is_not_equal_true;
42499
257
      } else {
42500
257
        goto is_not_equal_false;
42501
257
      }
42502
262
    }
42503
262
  }
42504
378
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42505
378
}
42506
42507
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42508
428
{
42509
428
  USE_OPLINE
42510
428
  zval *op1, *op2;
42511
428
  double d1, d2;
42512
42513
428
  op1 = EX_VAR(opline->op1.var);
42514
428
  op2 = RT_CONSTANT(opline, opline->op2);
42515
428
  if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42516
    /* pass */
42517
428
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42518
201
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42519
36
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42520
35
is_not_equal_true:
42521
35
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
42522
35
      } else {
42523
6
is_not_equal_false:
42524
6
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
42525
6
      }
42526
165
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42527
0
      d1 = (double)Z_LVAL_P(op1);
42528
0
      d2 = Z_DVAL_P(op2);
42529
0
      goto is_not_equal_double;
42530
0
    }
42531
227
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42532
125
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42533
0
      d1 = Z_DVAL_P(op1);
42534
0
      d2 = Z_DVAL_P(op2);
42535
0
is_not_equal_double:
42536
0
      if (d1 != d2) {
42537
0
        goto is_not_equal_true;
42538
0
      } else {
42539
0
        goto is_not_equal_false;
42540
0
      }
42541
125
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42542
0
      d1 = Z_DVAL_P(op1);
42543
0
      d2 = (double)Z_LVAL_P(op2);
42544
0
      goto is_not_equal_double;
42545
0
    }
42546
125
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42547
5
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42548
5
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42549
5
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42550
0
        zval_ptr_dtor_str(op1);
42551
0
      }
42552
5
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42553
0
        zval_ptr_dtor_str(op2);
42554
0
      }
42555
5
      if (!result) {
42556
5
        goto is_not_equal_true;
42557
5
      } else {
42558
0
        goto is_not_equal_false;
42559
0
      }
42560
5
    }
42561
5
  }
42562
428
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
42563
428
}
42564
42565
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42566
0
{
42567
0
  USE_OPLINE
42568
0
  zval *op1, *op2;
42569
42570
0
  SAVE_OPLINE();
42571
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42572
0
  op2 = RT_CONSTANT(opline, opline->op2);
42573
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
42574
42575
42576
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42577
0
}
42578
42579
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42580
0
{
42581
0
  USE_OPLINE
42582
0
  zval *op1, *op2;
42583
42584
0
  SAVE_OPLINE();
42585
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42586
0
  op2 = RT_CONSTANT(opline, opline->op2);
42587
0
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
42588
42589
42590
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42591
0
}
42592
42593
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42594
560
{
42595
560
  USE_OPLINE
42596
560
  zval *object;
42597
560
  zval *property;
42598
560
  zval *value;
42599
560
  zval *zptr;
42600
560
  void *_cache_slot[3] = {0};
42601
560
  void **cache_slot;
42602
560
  zend_property_info *prop_info;
42603
560
  zend_object *zobj;
42604
560
  zend_string *name, *tmp_name;
42605
42606
560
  SAVE_OPLINE();
42607
560
  object = EX_VAR(opline->op1.var);
42608
560
  property = RT_CONSTANT(opline, opline->op2);
42609
42610
560
  do {
42611
560
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
42612
42613
560
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42614
188
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42615
144
        object = Z_REFVAL_P(object);
42616
144
        goto assign_op_object;
42617
144
      }
42618
44
      if (IS_CV == IS_CV
42619
44
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42620
11
        ZVAL_UNDEFINED_OP1();
42621
11
      }
42622
44
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42623
44
      break;
42624
188
    }
42625
42626
516
assign_op_object:
42627
    /* here we are sure we are dealing with an object */
42628
516
    zobj = Z_OBJ_P(object);
42629
516
    if (IS_CONST == IS_CONST) {
42630
516
      name = Z_STR_P(property);
42631
516
    } else {
42632
0
      name = zval_try_get_tmp_string(property, &tmp_name);
42633
0
      if (UNEXPECTED(!name)) {
42634
0
        UNDEF_RESULT();
42635
0
        break;
42636
0
      }
42637
0
    }
42638
516
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
42639
516
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42640
353
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42641
50
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42642
11
          ZVAL_NULL(EX_VAR(opline->result.var));
42643
11
        }
42644
303
      } else {
42645
303
        zend_reference *ref;
42646
42647
303
        do {
42648
303
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
42649
56
            ref = Z_REF_P(zptr);
42650
56
            zptr = Z_REFVAL_P(zptr);
42651
56
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42652
51
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42653
51
              break;
42654
51
            }
42655
56
          }
42656
42657
252
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
42658
252
          if (prop_info) {
42659
            /* special case for typed properties */
42660
101
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
42661
151
          } else {
42662
151
            zend_binary_op(zptr, zptr, value OPLINE_CC);
42663
151
          }
42664
252
        } while (0);
42665
42666
303
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42667
81
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
42668
81
        }
42669
303
      }
42670
353
    } else {
42671
163
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
42672
163
    }
42673
516
    if (IS_CONST != IS_CONST) {
42674
0
      zend_tmp_string_release(tmp_name);
42675
0
    }
42676
516
  } while (0);
42677
42678
560
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42679
42680
42681
  /* assign_obj has two opcodes! */
42682
560
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
42683
560
}
42684
42685
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
42686
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42687
1.60k
{
42688
1.60k
  USE_OPLINE
42689
1.60k
  zval *var_ptr;
42690
1.60k
  zval *value, *container, *dim;
42691
1.60k
  HashTable *ht;
42692
42693
1.60k
  SAVE_OPLINE();
42694
1.60k
  container = EX_VAR(opline->op1.var);
42695
42696
1.60k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42697
1.47k
assign_dim_op_array:
42698
1.47k
    SEPARATE_ARRAY(container);
42699
1.47k
    ht = Z_ARRVAL_P(container);
42700
1.53k
assign_dim_op_new_array:
42701
1.53k
    dim = RT_CONSTANT(opline, opline->op2);
42702
1.53k
    if (IS_CONST == IS_UNUSED) {
42703
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
42704
0
      if (UNEXPECTED(!var_ptr)) {
42705
0
        zend_cannot_add_element();
42706
0
        goto assign_dim_op_ret_null;
42707
0
      }
42708
1.53k
    } else {
42709
1.53k
      if (IS_CONST == IS_CONST) {
42710
1.53k
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
42711
1.53k
      } else {
42712
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
42713
0
      }
42714
1.53k
      if (UNEXPECTED(!var_ptr)) {
42715
10
        goto assign_dim_op_ret_null;
42716
10
      }
42717
1.53k
    }
42718
42719
1.52k
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
42720
42721
1.52k
    do {
42722
1.52k
      if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
42723
47
        zend_reference *ref = Z_REF_P(var_ptr);
42724
47
        var_ptr = Z_REFVAL_P(var_ptr);
42725
47
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42726
47
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42727
47
          break;
42728
47
        }
42729
47
      }
42730
1.47k
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
42731
1.47k
    } while (0);
42732
42733
1.52k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42734
97
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
42735
97
    }
42736
1.52k
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42737
1.52k
  } else {
42738
128
    if (EXPECTED(Z_ISREF_P(container))) {
42739
0
      container = Z_REFVAL_P(container);
42740
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42741
0
        goto assign_dim_op_array;
42742
0
      }
42743
0
    }
42744
42745
128
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
42746
53
      zend_object *obj = Z_OBJ_P(container);
42747
42748
53
      dim = RT_CONSTANT(opline, opline->op2);
42749
53
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42750
0
        dim++;
42751
0
      }
42752
53
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
42753
75
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
42754
54
      uint8_t old_type;
42755
42756
54
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
42757
39
        ZVAL_UNDEFINED_OP1();
42758
39
      }
42759
54
      ht = zend_new_array(8);
42760
54
      old_type = Z_TYPE_P(container);
42761
54
      ZVAL_ARR(container, ht);
42762
54
      if (UNEXPECTED(old_type == IS_FALSE)) {
42763
15
        GC_ADDREF(ht);
42764
15
        zend_false_to_array_deprecated();
42765
15
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
42766
0
          zend_array_destroy(ht);
42767
0
          goto assign_dim_op_ret_null;
42768
0
        }
42769
15
      }
42770
54
      goto assign_dim_op_new_array;
42771
54
    } else {
42772
21
      dim = RT_CONSTANT(opline, opline->op2);
42773
21
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
42774
31
assign_dim_op_ret_null:
42775
31
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42776
31
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42777
26
        ZVAL_NULL(EX_VAR(opline->result.var));
42778
26
      }
42779
31
    }
42780
128
  }
42781
42782
42783
1.60k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
42784
1.60k
}
42785
42786
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42787
5.89k
{
42788
5.89k
  USE_OPLINE
42789
5.89k
  zval *var_ptr;
42790
5.89k
  zval *value;
42791
42792
5.89k
  SAVE_OPLINE();
42793
5.89k
  value = RT_CONSTANT(opline, opline->op2);
42794
5.89k
  var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
42795
42796
5.89k
  do {
42797
5.89k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
42798
1.20k
      zend_reference *ref = Z_REF_P(var_ptr);
42799
1.20k
      var_ptr = Z_REFVAL_P(var_ptr);
42800
1.20k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42801
90
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42802
90
        break;
42803
90
      }
42804
1.20k
    }
42805
5.80k
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
42806
5.80k
  } while (0);
42807
42808
5.89k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42809
1.55k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
42810
1.55k
  }
42811
42812
42813
5.89k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42814
5.89k
}
42815
42816
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42817
742
{
42818
742
  USE_OPLINE
42819
742
  zval *object;
42820
742
  zval *property;
42821
742
  zval *zptr;
42822
742
  void *_cache_slot[3] = {0};
42823
742
  void **cache_slot;
42824
742
  zend_property_info *prop_info;
42825
742
  zend_object *zobj;
42826
742
  zend_string *name, *tmp_name;
42827
42828
742
  SAVE_OPLINE();
42829
742
  object = EX_VAR(opline->op1.var);
42830
742
  property = RT_CONSTANT(opline, opline->op2);
42831
42832
742
  do {
42833
742
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42834
62
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42835
35
        object = Z_REFVAL_P(object);
42836
35
        goto pre_incdec_object;
42837
35
      }
42838
27
      if (IS_CV == IS_CV
42839
27
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42840
14
        ZVAL_UNDEFINED_OP1();
42841
14
      }
42842
27
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42843
27
      break;
42844
62
    }
42845
42846
715
pre_incdec_object:
42847
    /* here we are sure we are dealing with an object */
42848
715
    zobj = Z_OBJ_P(object);
42849
715
    if (IS_CONST == IS_CONST) {
42850
715
      name = Z_STR_P(property);
42851
715
    } else {
42852
0
      name = zval_try_get_tmp_string(property, &tmp_name);
42853
0
      if (UNEXPECTED(!name)) {
42854
0
        UNDEF_RESULT();
42855
0
        break;
42856
0
      }
42857
0
    }
42858
715
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
42859
715
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42860
540
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42861
19
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42862
14
          ZVAL_NULL(EX_VAR(opline->result.var));
42863
14
        }
42864
521
      } else {
42865
521
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
42866
521
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
42867
521
      }
42868
540
    } else {
42869
175
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
42870
175
    }
42871
715
    if (IS_CONST != IS_CONST) {
42872
0
      zend_tmp_string_release(tmp_name);
42873
0
    }
42874
715
  } while (0);
42875
42876
42877
742
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42878
742
}
42879
42880
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42881
298
{
42882
298
  USE_OPLINE
42883
298
  zval *object;
42884
298
  zval *property;
42885
298
  zval *zptr;
42886
298
  void *_cache_slot[3] = {0};
42887
298
  void **cache_slot;
42888
298
  zend_property_info *prop_info;
42889
298
  zend_object *zobj;
42890
298
  zend_string *name, *tmp_name;
42891
42892
298
  SAVE_OPLINE();
42893
298
  object = EX_VAR(opline->op1.var);
42894
298
  property = RT_CONSTANT(opline, opline->op2);
42895
42896
298
  do {
42897
298
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42898
25
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42899
0
        object = Z_REFVAL_P(object);
42900
0
        goto post_incdec_object;
42901
0
      }
42902
25
      if (IS_CV == IS_CV
42903
25
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42904
22
        ZVAL_UNDEFINED_OP1();
42905
22
      }
42906
25
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42907
25
      break;
42908
25
    }
42909
42910
273
post_incdec_object:
42911
    /* here we are sure we are dealing with an object */
42912
273
    zobj = Z_OBJ_P(object);
42913
273
    if (IS_CONST == IS_CONST) {
42914
273
      name = Z_STR_P(property);
42915
273
    } else {
42916
0
      name = zval_try_get_tmp_string(property, &tmp_name);
42917
0
      if (UNEXPECTED(!name)) {
42918
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
42919
0
        break;
42920
0
      }
42921
0
    }
42922
273
    cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
42923
273
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42924
255
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42925
47
        ZVAL_NULL(EX_VAR(opline->result.var));
42926
208
      } else {
42927
208
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
42928
208
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
42929
208
      }
42930
255
    } else {
42931
18
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
42932
18
    }
42933
273
    if (IS_CONST != IS_CONST) {
42934
0
      zend_tmp_string_release(tmp_name);
42935
0
    }
42936
273
  } while (0);
42937
42938
42939
298
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42940
298
}
42941
42942
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42943
5.08k
{
42944
5.08k
  USE_OPLINE
42945
5.08k
  zval *container, *dim, *value;
42946
42947
5.08k
  SAVE_OPLINE();
42948
5.08k
  container = EX_VAR(opline->op1.var);
42949
5.08k
  dim = RT_CONSTANT(opline, opline->op2);
42950
5.08k
  if (IS_CV != IS_CONST) {
42951
5.08k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42952
3.28k
fetch_dim_r_array:
42953
3.28k
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
42954
3.28k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42955
3.28k
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
42956
785
      container = Z_REFVAL_P(container);
42957
785
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42958
785
        goto fetch_dim_r_array;
42959
785
      } else {
42960
0
        goto fetch_dim_r_slow;
42961
0
      }
42962
1.80k
    } else {
42963
1.80k
fetch_dim_r_slow:
42964
1.80k
      if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42965
28
        dim++;
42966
28
      }
42967
1.80k
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
42968
1.80k
    }
42969
5.08k
  } else {
42970
0
    zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42971
0
  }
42972
42973
42974
5.08k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42975
5.08k
}
42976
42977
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42978
6.24k
{
42979
6.24k
  USE_OPLINE
42980
6.24k
  zval *container;
42981
42982
6.24k
  SAVE_OPLINE();
42983
6.24k
  container = EX_VAR(opline->op1.var);
42984
6.24k
  zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42985
42986
6.24k
  if (IS_CV == IS_VAR) {
42987
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42988
0
  }
42989
6.24k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42990
6.24k
}
42991
42992
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42993
260
{
42994
260
  USE_OPLINE
42995
260
  zval *container;
42996
42997
260
  SAVE_OPLINE();
42998
260
  container = EX_VAR(opline->op1.var);
42999
260
  zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
43000
43001
260
  if (IS_CV == IS_VAR) {
43002
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43003
0
  }
43004
260
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43005
260
}
43006
43007
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43008
1.00k
{
43009
1.00k
  USE_OPLINE
43010
1.00k
  zval *container;
43011
43012
1.00k
  SAVE_OPLINE();
43013
1.00k
  container = EX_VAR(opline->op1.var);
43014
1.00k
  zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
43015
43016
43017
1.00k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43018
1.00k
}
43019
43020
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43021
154
{
43022
#if 0
43023
  USE_OPLINE
43024
#endif
43025
43026
154
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
43027
22
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
43028
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43029
0
    }
43030
22
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43031
132
  } else {
43032
132
    if (IS_CONST == IS_UNUSED) {
43033
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43034
0
    }
43035
132
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43036
132
  }
43037
154
}
43038
43039
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43040
115
{
43041
115
  USE_OPLINE
43042
115
  zval *container;
43043
43044
115
  SAVE_OPLINE();
43045
115
  container = EX_VAR(opline->op1.var);
43046
115
  zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
43047
43048
115
  if (IS_CV == IS_VAR) {
43049
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43050
0
  }
43051
115
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43052
115
}
43053
43054
static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43055
35.8k
{
43056
35.8k
  USE_OPLINE
43057
35.8k
  zval *container;
43058
35.8k
  void **cache_slot = NULL;
43059
43060
35.8k
  SAVE_OPLINE();
43061
35.8k
  container = EX_VAR(opline->op1.var);
43062
43063
35.8k
  if (IS_CV == IS_CONST ||
43064
35.8k
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
43065
25.7k
    do {
43066
25.7k
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
43067
723
        container = Z_REFVAL_P(container);
43068
723
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
43069
507
          break;
43070
507
        }
43071
723
      }
43072
25.2k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
43073
24.2k
        ZVAL_UNDEFINED_OP1();
43074
24.2k
      }
43075
25.2k
      zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
43076
25.2k
      ZVAL_NULL(EX_VAR(opline->result.var));
43077
25.2k
      goto fetch_obj_r_finish;
43078
25.7k
    } while (0);
43079
25.7k
  }
43080
43081
  /* here we are sure we are dealing with an object */
43082
10.5k
  do {
43083
10.5k
    zend_object *zobj = Z_OBJ_P(container);
43084
10.5k
    zend_string *name, *tmp_name;
43085
10.5k
    zval *retval;
43086
43087
10.5k
    if (IS_CONST == IS_CONST) {
43088
10.5k
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
43089
43090
10.5k
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
43091
2.38k
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43092
43093
2.38k
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43094
1.27k
fetch_obj_r_simple:
43095
1.27k
          retval = OBJ_PROP(zobj, prop_offset);
43096
1.27k
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
43097
1.13k
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43098
0
              goto fetch_obj_r_copy;
43099
1.13k
            } else {
43100
1.33k
fetch_obj_r_fast_copy:
43101
1.33k
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43102
1.33k
              ZEND_VM_NEXT_OPCODE();
43103
1.33k
            }
43104
1.13k
          }
43105
1.27k
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
43106
79
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43107
79
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
43108
5
            prop_offset = prop_info->offset;
43109
5
            goto fetch_obj_r_simple;
43110
74
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
43111
34
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
43112
34
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
43113
34
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
43114
43115
34
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
43116
34
            if (IS_CV & IS_CV) {
43117
34
              GC_ADDREF(zobj);
43118
34
            }
43119
34
            if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
43120
34
              call_info |= ZEND_CALL_RELEASE_THIS;
43121
34
            }
43122
34
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
43123
34
            call->prev_execute_data = execute_data;
43124
34
            call->call = NULL;
43125
34
            call->return_value = EX_VAR(opline->result.var);
43126
34
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
43127
43128
34
            execute_data = call;
43129
34
            EG(current_execute_data) = execute_data;
43130
34
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
43131
43132
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
43133
            opline = hook->op_array.opcodes;
43134
#else
43135
34
            EX(opline) = hook->op_array.opcodes;
43136
34
#endif
43137
34
            LOAD_OPLINE_EX();
43138
43139
43140
34
            ZEND_VM_ENTER_EX();
43141
34
          }
43142
          /* Fall through to read_property for hooks. */
43143
1.03k
        } else if (EXPECTED(zobj->properties != NULL)) {
43144
481
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
43145
481
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43146
481
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
43147
201
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
43148
43149
201
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
43150
201
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
43151
43152
201
              if (EXPECTED(p->key == name) ||
43153
201
                  (EXPECTED(p->h == ZSTR_H(name)) &&
43154
0
                   EXPECTED(p->key != NULL) &&
43155
201
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
43156
201
                retval = &p->val;
43157
201
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43158
0
                  goto fetch_obj_r_copy;
43159
201
                } else {
43160
201
                  goto fetch_obj_r_fast_copy;
43161
201
                }
43162
201
              }
43163
201
            }
43164
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
43165
0
          }
43166
280
          retval = zend_hash_find_known_hash(zobj->properties, name);
43167
280
          if (EXPECTED(retval)) {
43168
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
43169
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
43170
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43171
0
              goto fetch_obj_r_copy;
43172
0
            } else {
43173
0
              goto fetch_obj_r_fast_copy;
43174
0
            }
43175
0
          }
43176
280
        }
43177
2.38k
      }
43178
9.19k
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43179
9.19k
    } else {
43180
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43181
0
      if (UNEXPECTED(!name)) {
43182
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
43183
0
        break;
43184
0
      }
43185
0
    }
43186
43187
9.19k
#if ZEND_DEBUG
43188
    /* For non-standard object handlers, verify a declared property type in debug builds.
43189
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
43190
9.19k
    zend_property_info *prop_info = NULL;
43191
9.19k
    if (zobj->handlers->read_property != zend_std_read_property) {
43192
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
43193
0
    }
43194
9.19k
#endif
43195
9.19k
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
43196
9.19k
#if ZEND_DEBUG
43197
9.19k
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
43198
9.19k
        && ZEND_TYPE_IS_SET(prop_info->type)) {
43199
0
      ZVAL_OPT_DEREF(retval);
43200
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
43201
0
    }
43202
9.19k
#endif
43203
43204
9.19k
    if (IS_CONST != IS_CONST) {
43205
0
      zend_tmp_string_release(tmp_name);
43206
0
    }
43207
43208
9.19k
    if (retval != EX_VAR(opline->result.var)) {
43209
8.23k
fetch_obj_r_copy:
43210
8.23k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43211
8.23k
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
43212
120
      zend_unwrap_reference(retval);
43213
120
    }
43214
9.19k
  } while (0);
43215
43216
34.4k
fetch_obj_r_finish:
43217
43218
43219
34.4k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43220
34.4k
}
43221
43222
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43223
35.8k
{
43224
35.8k
  ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43225
35.8k
}
43226
43227
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43228
2.15k
{
43229
2.15k
  USE_OPLINE
43230
2.15k
  zval *property, *container, *result;
43231
43232
2.15k
  SAVE_OPLINE();
43233
43234
2.15k
  container = EX_VAR(opline->op1.var);
43235
2.15k
  property = RT_CONSTANT(opline, opline->op2);
43236
2.15k
  result = EX_VAR(opline->result.var);
43237
2.15k
  zend_fetch_property_address(
43238
2.15k
    result, container, IS_CV, property, IS_CONST,
43239
2.15k
    ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
43240
2.15k
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
43241
43242
2.15k
  if (IS_CV == IS_VAR) {
43243
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43244
0
  }
43245
2.15k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43246
2.15k
}
43247
43248
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43249
59
{
43250
59
  USE_OPLINE
43251
59
  zval *property, *container, *result;
43252
43253
59
  SAVE_OPLINE();
43254
59
  container = EX_VAR(opline->op1.var);
43255
59
  property = RT_CONSTANT(opline, opline->op2);
43256
59
  result = EX_VAR(opline->result.var);
43257
59
  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);
43258
43259
59
  if (IS_CV == IS_VAR) {
43260
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43261
0
  }
43262
59
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43263
59
}
43264
43265
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43266
383
{
43267
383
  USE_OPLINE
43268
383
  zval *container;
43269
383
  void **cache_slot = NULL;
43270
43271
383
  SAVE_OPLINE();
43272
383
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
43273
43274
383
  if (IS_CV == IS_CONST ||
43275
383
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
43276
45
    do {
43277
45
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
43278
0
        container = Z_REFVAL_P(container);
43279
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
43280
0
          break;
43281
0
        }
43282
0
      }
43283
45
      if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
43284
0
        ZVAL_UNDEFINED_OP2();
43285
0
      }
43286
45
      ZVAL_NULL(EX_VAR(opline->result.var));
43287
45
      goto fetch_obj_is_finish;
43288
45
    } while (0);
43289
45
  }
43290
43291
  /* here we are sure we are dealing with an object */
43292
338
  do {
43293
338
    zend_object *zobj = Z_OBJ_P(container);
43294
338
    zend_string *name, *tmp_name;
43295
338
    zval *retval;
43296
43297
338
    if (IS_CONST == IS_CONST) {
43298
338
      cache_slot = CACHE_ADDR(opline->extended_value);
43299
43300
338
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
43301
80
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43302
43303
80
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43304
18
fetch_obj_is_simple:
43305
18
          retval = OBJ_PROP(zobj, prop_offset);
43306
18
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
43307
3
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43308
0
              goto fetch_obj_is_copy;
43309
3
            } else {
43310
51
fetch_obj_is_fast_copy:
43311
51
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43312
51
              ZEND_VM_NEXT_OPCODE();
43313
51
            }
43314
3
          }
43315
62
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
43316
5
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
43317
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43318
0
            prop_offset = prop_info->offset;
43319
0
            goto fetch_obj_is_simple;
43320
0
          }
43321
          /* Fall through to read_property for hooks. */
43322
57
        } else if (EXPECTED(zobj->properties != NULL)) {
43323
55
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
43324
55
          name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43325
55
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
43326
48
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
43327
43328
48
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
43329
48
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
43330
43331
48
              if (EXPECTED(p->key == name) ||
43332
48
                  (EXPECTED(p->h == ZSTR_H(name)) &&
43333
8
                   EXPECTED(p->key != NULL) &&
43334
40
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
43335
40
                retval = &p->val;
43336
40
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43337
0
                  goto fetch_obj_is_copy;
43338
40
                } else {
43339
40
                  goto fetch_obj_is_fast_copy;
43340
40
                }
43341
40
              }
43342
48
            }
43343
8
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
43344
8
          }
43345
15
          retval = zend_hash_find_known_hash(zobj->properties, name);
43346
15
          if (EXPECTED(retval)) {
43347
8
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
43348
8
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
43349
8
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43350
0
              goto fetch_obj_is_copy;
43351
8
            } else {
43352
8
              goto fetch_obj_is_fast_copy;
43353
8
            }
43354
8
          }
43355
15
        }
43356
80
      }
43357
287
      name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43358
287
    } else {
43359
0
      name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43360
0
      if (UNEXPECTED(!name)) {
43361
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
43362
0
        break;
43363
0
      }
43364
0
    }
43365
43366
287
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
43367
43368
287
    if (IS_CONST != IS_CONST) {
43369
0
      zend_tmp_string_release(tmp_name);
43370
0
    }
43371
43372
287
    if (retval != EX_VAR(opline->result.var)) {
43373
257
fetch_obj_is_copy:
43374
257
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43375
257
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
43376
15
      zend_unwrap_reference(retval);
43377
15
    }
43378
287
  } while (0);
43379
43380
332
fetch_obj_is_finish:
43381
43382
43383
332
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43384
332
}
43385
43386
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43387
79
{
43388
#if 0
43389
  USE_OPLINE
43390
#endif
43391
43392
79
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
43393
    /* Behave like FETCH_OBJ_W */
43394
17
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
43395
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43396
0
    }
43397
17
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43398
62
  } else {
43399
62
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43400
62
  }
43401
79
}
43402
43403
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43404
115
{
43405
115
  USE_OPLINE
43406
115
  zval *container, *property, *result;
43407
43408
115
  SAVE_OPLINE();
43409
115
  container = EX_VAR(opline->op1.var);
43410
115
  property = RT_CONSTANT(opline, opline->op2);
43411
115
  result = EX_VAR(opline->result.var);
43412
115
  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);
43413
43414
115
  if (IS_CV == IS_VAR) {
43415
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43416
0
  }
43417
115
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43418
115
}
43419
43420
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43421
4.36k
{
43422
4.36k
  USE_OPLINE
43423
4.36k
  zval *object, *value, tmp;
43424
4.36k
  zend_object *zobj;
43425
4.36k
  zend_string *name, *tmp_name;
43426
4.36k
  zend_refcounted *garbage = NULL;
43427
43428
4.36k
  SAVE_OPLINE();
43429
4.36k
  object = EX_VAR(opline->op1.var);
43430
4.36k
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
43431
43432
4.36k
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43433
515
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43434
454
      object = Z_REFVAL_P(object);
43435
454
      goto assign_object;
43436
454
    }
43437
61
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43438
61
    value = &EG(uninitialized_zval);
43439
61
    goto free_and_exit_assign_obj;
43440
515
  }
43441
43442
4.30k
assign_object:
43443
4.30k
  zobj = Z_OBJ_P(object);
43444
4.30k
  if (IS_CONST == IS_CONST) {
43445
4.30k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43446
1.28k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
43447
1.28k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43448
1.28k
      zval *property_val;
43449
1.28k
      zend_property_info *prop_info;
43450
43451
1.28k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43452
252
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43453
43454
252
assign_obj_simple:
43455
252
        property_val = OBJ_PROP(zobj, prop_offset);
43456
252
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
43457
197
          if (prop_info != NULL) {
43458
107
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43459
107
            goto free_and_exit_assign_obj;
43460
107
          } else {
43461
439
fast_assign_obj:
43462
439
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43463
439
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43464
102
              ZVAL_COPY(EX_VAR(opline->result.var), value);
43465
102
            }
43466
439
            goto exit_assign_obj;
43467
90
          }
43468
197
        }
43469
1.03k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43470
1.00k
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43471
1.00k
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43472
15
          zobj = zend_lazy_object_init(zobj);
43473
15
          if (!zobj) {
43474
5
            value = &EG(uninitialized_zval);
43475
5
            goto free_and_exit_assign_obj;
43476
5
          }
43477
15
        }
43478
997
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43479
843
          rebuild_object_properties_internal(zobj);
43480
843
        }
43481
997
        if (EXPECTED(zobj->properties != NULL)) {
43482
987
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43483
109
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43484
109
              GC_DELREF(zobj->properties);
43485
109
            }
43486
109
            zobj->properties = zend_array_dup(zobj->properties);
43487
109
          }
43488
987
          property_val = zend_hash_find_known_hash(zobj->properties, name);
43489
987
          if (property_val) {
43490
349
            goto fast_assign_obj;
43491
349
          }
43492
987
        }
43493
43494
648
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43495
608
          if (IS_CONST == IS_CONST) {
43496
608
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43497
0
              Z_ADDREF_P(value);
43498
0
            }
43499
608
          } else if (IS_CONST != IS_TMP_VAR) {
43500
0
            if (Z_ISREF_P(value)) {
43501
0
              if (IS_CONST == IS_VAR) {
43502
0
                zend_reference *ref = Z_REF_P(value);
43503
0
                if (GC_DELREF(ref) == 0) {
43504
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43505
0
                  efree_size(ref, sizeof(zend_reference));
43506
0
                  value = &tmp;
43507
0
                } else {
43508
0
                  value = Z_REFVAL_P(value);
43509
0
                  Z_TRY_ADDREF_P(value);
43510
0
                }
43511
0
              } else {
43512
0
                value = Z_REFVAL_P(value);
43513
0
                Z_TRY_ADDREF_P(value);
43514
0
              }
43515
0
            } else if (IS_CONST == IS_CV) {
43516
0
              Z_TRY_ADDREF_P(value);
43517
0
            }
43518
0
          }
43519
608
          zend_hash_add_new(zobj->properties, name, value);
43520
608
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43521
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
43522
0
          }
43523
608
          goto exit_assign_obj;
43524
608
        }
43525
648
      } else {
43526
31
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43527
31
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43528
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
43529
0
          prop_offset = prop_info->offset;
43530
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43531
0
            prop_info = NULL;
43532
0
          }
43533
0
          goto assign_obj_simple;
43534
0
        }
43535
        /* Fall through to write_property for hooks. */
43536
31
      }
43537
1.28k
    }
43538
3.14k
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43539
3.14k
  } else {
43540
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43541
0
    if (UNEXPECTED(!name)) {
43542
43543
0
      UNDEF_RESULT();
43544
0
      goto exit_assign_obj;
43545
0
    }
43546
0
  }
43547
43548
3.14k
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
43549
0
    ZVAL_DEREF(value);
43550
0
  }
43551
43552
3.14k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43553
43554
3.14k
  if (IS_CONST != IS_CONST) {
43555
0
    zend_tmp_string_release(tmp_name);
43556
0
  }
43557
43558
3.31k
free_and_exit_assign_obj:
43559
3.31k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43560
224
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43561
224
  }
43562
43563
4.35k
exit_assign_obj:
43564
4.35k
  if (garbage) {
43565
62
    GC_DTOR_NO_REF(garbage);
43566
62
  }
43567
43568
43569
  /* assign_obj has two opcodes! */
43570
4.35k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
43571
4.35k
}
43572
43573
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43574
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43575
857
{
43576
857
  USE_OPLINE
43577
857
  zval *object, *value, tmp;
43578
857
  zend_object *zobj;
43579
857
  zend_string *name, *tmp_name;
43580
857
  zend_refcounted *garbage = NULL;
43581
43582
857
  SAVE_OPLINE();
43583
857
  object = EX_VAR(opline->op1.var);
43584
857
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
43585
43586
857
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43587
472
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43588
452
      object = Z_REFVAL_P(object);
43589
452
      goto assign_object;
43590
452
    }
43591
20
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43592
20
    value = &EG(uninitialized_zval);
43593
20
    goto free_and_exit_assign_obj;
43594
472
  }
43595
43596
837
assign_object:
43597
837
  zobj = Z_OBJ_P(object);
43598
837
  if (IS_CONST == IS_CONST) {
43599
837
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43600
460
      void **cache_slot = CACHE_ADDR(opline->extended_value);
43601
460
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43602
460
      zval *property_val;
43603
460
      zend_property_info *prop_info;
43604
43605
460
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43606
273
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43607
43608
273
assign_obj_simple:
43609
273
        property_val = OBJ_PROP(zobj, prop_offset);
43610
273
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
43611
273
          if (prop_info != NULL) {
43612
222
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43613
222
            goto free_and_exit_assign_obj;
43614
222
          } else {
43615
109
fast_assign_obj:
43616
109
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
43617
109
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43618
54
              ZVAL_COPY(EX_VAR(opline->result.var), value);
43619
54
            }
43620
109
            goto exit_assign_obj;
43621
51
          }
43622
273
        }
43623
273
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43624
187
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43625
187
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43626
0
          zobj = zend_lazy_object_init(zobj);
43627
0
          if (!zobj) {
43628
0
            value = &EG(uninitialized_zval);
43629
0
            goto free_and_exit_assign_obj;
43630
0
          }
43631
0
        }
43632
187
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43633
9
          rebuild_object_properties_internal(zobj);
43634
9
        }
43635
187
        if (EXPECTED(zobj->properties != NULL)) {
43636
169
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43637
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43638
0
              GC_DELREF(zobj->properties);
43639
0
            }
43640
0
            zobj->properties = zend_array_dup(zobj->properties);
43641
0
          }
43642
169
          property_val = zend_hash_find_known_hash(zobj->properties, name);
43643
169
          if (property_val) {
43644
58
            goto fast_assign_obj;
43645
58
          }
43646
169
        }
43647
43648
129
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43649
9
          if (IS_TMP_VAR == IS_CONST) {
43650
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43651
0
              Z_ADDREF_P(value);
43652
0
            }
43653
9
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
43654
0
            if (Z_ISREF_P(value)) {
43655
0
              if (IS_TMP_VAR == IS_VAR) {
43656
0
                zend_reference *ref = Z_REF_P(value);
43657
0
                if (GC_DELREF(ref) == 0) {
43658
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43659
0
                  efree_size(ref, sizeof(zend_reference));
43660
0
                  value = &tmp;
43661
0
                } else {
43662
0
                  value = Z_REFVAL_P(value);
43663
0
                  Z_TRY_ADDREF_P(value);
43664
0
                }
43665
0
              } else {
43666
0
                value = Z_REFVAL_P(value);
43667
0
                Z_TRY_ADDREF_P(value);
43668
0
              }
43669
0
            } else if (IS_TMP_VAR == IS_CV) {
43670
0
              Z_TRY_ADDREF_P(value);
43671
0
            }
43672
0
          }
43673
9
          zend_hash_add_new(zobj->properties, name, value);
43674
9
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43675
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
43676
0
          }
43677
9
          goto exit_assign_obj;
43678
9
        }
43679
129
      } else {
43680
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43681
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43682
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
43683
0
          prop_offset = prop_info->offset;
43684
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43685
0
            prop_info = NULL;
43686
0
          }
43687
0
          goto assign_obj_simple;
43688
0
        }
43689
        /* Fall through to write_property for hooks. */
43690
0
      }
43691
460
    }
43692
497
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43693
497
  } else {
43694
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43695
0
    if (UNEXPECTED(!name)) {
43696
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43697
0
      UNDEF_RESULT();
43698
0
      goto exit_assign_obj;
43699
0
    }
43700
0
  }
43701
43702
497
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
43703
0
    ZVAL_DEREF(value);
43704
0
  }
43705
43706
497
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43707
43708
497
  if (IS_CONST != IS_CONST) {
43709
0
    zend_tmp_string_release(tmp_name);
43710
0
  }
43711
43712
739
free_and_exit_assign_obj:
43713
739
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43714
479
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43715
479
  }
43716
739
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43717
857
exit_assign_obj:
43718
857
  if (garbage) {
43719
95
    GC_DTOR_NO_REF(garbage);
43720
95
  }
43721
43722
43723
  /* assign_obj has two opcodes! */
43724
857
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
43725
857
}
43726
43727
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43728
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43729
657
{
43730
657
  USE_OPLINE
43731
657
  zval *object, *value, tmp;
43732
657
  zend_object *zobj;
43733
657
  zend_string *name, *tmp_name;
43734
657
  zend_refcounted *garbage = NULL;
43735
43736
657
  SAVE_OPLINE();
43737
657
  object = EX_VAR(opline->op1.var);
43738
657
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43739
43740
657
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43741
70
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43742
57
      object = Z_REFVAL_P(object);
43743
57
      goto assign_object;
43744
57
    }
43745
13
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43746
13
    value = &EG(uninitialized_zval);
43747
13
    goto free_and_exit_assign_obj;
43748
70
  }
43749
43750
644
assign_object:
43751
644
  zobj = Z_OBJ_P(object);
43752
644
  if (IS_CONST == IS_CONST) {
43753
644
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43754
144
      void **cache_slot = CACHE_ADDR(opline->extended_value);
43755
144
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43756
144
      zval *property_val;
43757
144
      zend_property_info *prop_info;
43758
43759
144
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43760
30
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43761
43762
30
assign_obj_simple:
43763
30
        property_val = OBJ_PROP(zobj, prop_offset);
43764
30
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
43765
30
          if (prop_info != NULL) {
43766
10
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43767
10
            goto free_and_exit_assign_obj;
43768
20
          } else {
43769
26
fast_assign_obj:
43770
26
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
43771
26
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43772
12
              ZVAL_COPY(EX_VAR(opline->result.var), value);
43773
12
            }
43774
26
            goto exit_assign_obj;
43775
20
          }
43776
30
        }
43777
114
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43778
114
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43779
114
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43780
0
          zobj = zend_lazy_object_init(zobj);
43781
0
          if (!zobj) {
43782
0
            value = &EG(uninitialized_zval);
43783
0
            goto free_and_exit_assign_obj;
43784
0
          }
43785
0
        }
43786
114
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43787
0
          rebuild_object_properties_internal(zobj);
43788
0
        }
43789
114
        if (EXPECTED(zobj->properties != NULL)) {
43790
6
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43791
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43792
0
              GC_DELREF(zobj->properties);
43793
0
            }
43794
0
            zobj->properties = zend_array_dup(zobj->properties);
43795
0
          }
43796
6
          property_val = zend_hash_find_known_hash(zobj->properties, name);
43797
6
          if (property_val) {
43798
6
            goto fast_assign_obj;
43799
6
          }
43800
6
        }
43801
43802
108
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43803
0
          if (IS_VAR == IS_CONST) {
43804
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43805
0
              Z_ADDREF_P(value);
43806
0
            }
43807
0
          } else if (IS_VAR != IS_TMP_VAR) {
43808
0
            if (Z_ISREF_P(value)) {
43809
0
              if (IS_VAR == IS_VAR) {
43810
0
                zend_reference *ref = Z_REF_P(value);
43811
0
                if (GC_DELREF(ref) == 0) {
43812
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43813
0
                  efree_size(ref, sizeof(zend_reference));
43814
0
                  value = &tmp;
43815
0
                } else {
43816
0
                  value = Z_REFVAL_P(value);
43817
0
                  Z_TRY_ADDREF_P(value);
43818
0
                }
43819
0
              } else {
43820
0
                value = Z_REFVAL_P(value);
43821
0
                Z_TRY_ADDREF_P(value);
43822
0
              }
43823
0
            } else if (IS_VAR == IS_CV) {
43824
0
              Z_TRY_ADDREF_P(value);
43825
0
            }
43826
0
          }
43827
0
          zend_hash_add_new(zobj->properties, name, value);
43828
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43829
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
43830
0
          }
43831
0
          goto exit_assign_obj;
43832
0
        }
43833
108
      } else {
43834
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43835
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43836
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
43837
0
          prop_offset = prop_info->offset;
43838
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43839
0
            prop_info = NULL;
43840
0
          }
43841
0
          goto assign_obj_simple;
43842
0
        }
43843
        /* Fall through to write_property for hooks. */
43844
0
      }
43845
144
    }
43846
608
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43847
608
  } else {
43848
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43849
0
    if (UNEXPECTED(!name)) {
43850
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43851
0
      UNDEF_RESULT();
43852
0
      goto exit_assign_obj;
43853
0
    }
43854
0
  }
43855
43856
608
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
43857
608
    ZVAL_DEREF(value);
43858
608
  }
43859
43860
608
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43861
43862
608
  if (IS_CONST != IS_CONST) {
43863
0
    zend_tmp_string_release(tmp_name);
43864
0
  }
43865
43866
631
free_and_exit_assign_obj:
43867
631
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43868
161
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43869
161
  }
43870
631
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43871
657
exit_assign_obj:
43872
657
  if (garbage) {
43873
0
    GC_DTOR_NO_REF(garbage);
43874
0
  }
43875
43876
43877
  /* assign_obj has two opcodes! */
43878
657
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
43879
657
}
43880
43881
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43882
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43883
6.34k
{
43884
6.34k
  USE_OPLINE
43885
6.34k
  zval *object, *value, tmp;
43886
6.34k
  zend_object *zobj;
43887
6.34k
  zend_string *name, *tmp_name;
43888
6.34k
  zend_refcounted *garbage = NULL;
43889
43890
6.34k
  SAVE_OPLINE();
43891
6.34k
  object = EX_VAR(opline->op1.var);
43892
6.34k
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
43893
43894
6.34k
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43895
119
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43896
42
      object = Z_REFVAL_P(object);
43897
42
      goto assign_object;
43898
42
    }
43899
77
    zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43900
77
    value = &EG(uninitialized_zval);
43901
77
    goto free_and_exit_assign_obj;
43902
119
  }
43903
43904
6.27k
assign_object:
43905
6.27k
  zobj = Z_OBJ_P(object);
43906
6.27k
  if (IS_CONST == IS_CONST) {
43907
6.27k
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43908
5.20k
      void **cache_slot = CACHE_ADDR(opline->extended_value);
43909
5.20k
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43910
5.20k
      zval *property_val;
43911
5.20k
      zend_property_info *prop_info;
43912
43913
5.20k
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43914
3.15k
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43915
43916
3.15k
assign_obj_simple:
43917
3.15k
        property_val = OBJ_PROP(zobj, prop_offset);
43918
3.15k
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
43919
3.15k
          if (prop_info != NULL) {
43920
8
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43921
8
            goto free_and_exit_assign_obj;
43922
3.14k
          } else {
43923
3.76k
fast_assign_obj:
43924
3.76k
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
43925
3.76k
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43926
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
43927
0
            }
43928
3.76k
            goto exit_assign_obj;
43929
3.14k
          }
43930
3.15k
        }
43931
3.15k
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43932
2.04k
        name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43933
2.04k
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43934
0
          zobj = zend_lazy_object_init(zobj);
43935
0
          if (!zobj) {
43936
0
            value = &EG(uninitialized_zval);
43937
0
            goto free_and_exit_assign_obj;
43938
0
          }
43939
0
        }
43940
2.04k
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43941
1.34k
          rebuild_object_properties_internal(zobj);
43942
1.34k
        }
43943
2.04k
        if (EXPECTED(zobj->properties != NULL)) {
43944
1.74k
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43945
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43946
0
              GC_DELREF(zobj->properties);
43947
0
            }
43948
0
            zobj->properties = zend_array_dup(zobj->properties);
43949
0
          }
43950
1.74k
          property_val = zend_hash_find_known_hash(zobj->properties, name);
43951
1.74k
          if (property_val) {
43952
616
            goto fast_assign_obj;
43953
616
          }
43954
1.74k
        }
43955
43956
1.42k
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43957
1.01k
          if (IS_CV == IS_CONST) {
43958
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43959
0
              Z_ADDREF_P(value);
43960
0
            }
43961
1.01k
          } else if (IS_CV != IS_TMP_VAR) {
43962
1.01k
            if (Z_ISREF_P(value)) {
43963
0
              if (IS_CV == IS_VAR) {
43964
0
                zend_reference *ref = Z_REF_P(value);
43965
0
                if (GC_DELREF(ref) == 0) {
43966
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43967
0
                  efree_size(ref, sizeof(zend_reference));
43968
0
                  value = &tmp;
43969
0
                } else {
43970
0
                  value = Z_REFVAL_P(value);
43971
0
                  Z_TRY_ADDREF_P(value);
43972
0
                }
43973
0
              } else {
43974
0
                value = Z_REFVAL_P(value);
43975
0
                Z_TRY_ADDREF_P(value);
43976
0
              }
43977
1.01k
            } else if (IS_CV == IS_CV) {
43978
1.01k
              Z_TRY_ADDREF_P(value);
43979
1.01k
            }
43980
1.01k
          }
43981
1.01k
          zend_hash_add_new(zobj->properties, name, value);
43982
1.01k
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43983
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
43984
0
          }
43985
1.01k
          goto exit_assign_obj;
43986
1.01k
        }
43987
1.42k
      } else {
43988
5
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43989
5
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43990
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
43991
0
          prop_offset = prop_info->offset;
43992
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43993
0
            prop_info = NULL;
43994
0
          }
43995
0
          goto assign_obj_simple;
43996
0
        }
43997
        /* Fall through to write_property for hooks. */
43998
5
      }
43999
5.20k
    }
44000
1.48k
    name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
44001
1.48k
  } else {
44002
0
    name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
44003
0
    if (UNEXPECTED(!name)) {
44004
44005
0
      UNDEF_RESULT();
44006
0
      goto exit_assign_obj;
44007
0
    }
44008
0
  }
44009
44010
1.48k
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
44011
1.48k
    ZVAL_DEREF(value);
44012
1.48k
  }
44013
44014
1.48k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
44015
44016
1.48k
  if (IS_CONST != IS_CONST) {
44017
0
    zend_tmp_string_release(tmp_name);
44018
0
  }
44019
44020
1.56k
free_and_exit_assign_obj:
44021
1.56k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
44022
48
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
44023
48
  }
44024
44025
6.34k
exit_assign_obj:
44026
6.34k
  if (garbage) {
44027
1.79k
    GC_DTOR_NO_REF(garbage);
44028
1.79k
  }
44029
44030
44031
  /* assign_obj has two opcodes! */
44032
6.34k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44033
6.34k
}
44034
44035
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
44036
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44037
1.49k
{
44038
1.49k
  USE_OPLINE
44039
1.49k
  zval *object_ptr, *orig_object_ptr;
44040
1.49k
  zval *value;
44041
1.49k
  zval *variable_ptr;
44042
1.49k
  zval *dim;
44043
1.49k
  zend_refcounted *garbage = NULL;
44044
44045
1.49k
  SAVE_OPLINE();
44046
1.49k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44047
44048
1.49k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44049
1.04k
try_assign_dim_array:
44050
1.04k
    SEPARATE_ARRAY(object_ptr);
44051
1.04k
    if (IS_CONST == IS_UNUSED) {
44052
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
44053
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44054
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
44055
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44056
0
          GC_ADDREF(ht);
44057
0
        }
44058
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44059
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44060
0
          zend_array_destroy(ht);
44061
0
          goto assign_dim_error;
44062
0
        }
44063
0
      }
44064
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
44065
0
        ZVAL_DEREF(value);
44066
0
      }
44067
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44068
0
      if (UNEXPECTED(value == NULL)) {
44069
0
        zend_cannot_add_element();
44070
0
        goto assign_dim_error;
44071
0
      } else if (IS_CONST == IS_CV) {
44072
0
        if (Z_REFCOUNTED_P(value)) {
44073
0
          Z_ADDREF_P(value);
44074
0
        }
44075
0
      } else if (IS_CONST == IS_VAR) {
44076
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
44077
0
        if (Z_ISREF_P(free_op_data)) {
44078
0
          if (Z_REFCOUNTED_P(value)) {
44079
0
            Z_ADDREF_P(value);
44080
0
          }
44081
0
          zval_ptr_dtor_nogc(free_op_data);
44082
0
        }
44083
0
      } else if (IS_CONST == IS_CONST) {
44084
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44085
0
          Z_ADDREF_P(value);
44086
0
        }
44087
0
      }
44088
1.04k
    } else {
44089
1.04k
      dim = RT_CONSTANT(opline, opline->op2);
44090
1.04k
      if (IS_CONST == IS_CONST) {
44091
1.04k
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44092
1.04k
      } else {
44093
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44094
0
      }
44095
1.04k
      if (UNEXPECTED(variable_ptr == NULL)) {
44096
12
        goto assign_dim_error;
44097
12
      }
44098
1.03k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
44099
1.03k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44100
1.03k
    }
44101
1.03k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44102
199
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44103
199
    }
44104
1.03k
    if (garbage) {
44105
21
      GC_DTOR_NO_REF(garbage);
44106
21
    }
44107
1.03k
  } else {
44108
1.02k
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
44109
383
      object_ptr = Z_REFVAL_P(object_ptr);
44110
383
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44111
381
        goto try_assign_dim_array;
44112
381
      }
44113
383
    }
44114
644
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44115
225
      zend_object *obj = Z_OBJ_P(object_ptr);
44116
44117
225
      GC_ADDREF(obj);
44118
225
      dim = RT_CONSTANT(opline, opline->op2);
44119
225
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44120
0
        dim = ZVAL_UNDEFINED_OP2();
44121
225
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44122
70
        dim++;
44123
70
      }
44124
44125
225
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
44126
225
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44127
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44128
225
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
44129
0
        ZVAL_DEREF(value);
44130
0
      }
44131
44132
225
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44133
44134
225
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44135
0
        zend_objects_store_del(obj);
44136
0
      }
44137
419
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44138
216
      if (IS_CONST == IS_UNUSED) {
44139
0
        zend_use_new_element_for_string();
44140
44141
0
        UNDEF_RESULT();
44142
216
      } else {
44143
216
        dim = RT_CONSTANT(opline, opline->op2);
44144
216
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
44145
216
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44146
44147
216
      }
44148
216
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44149
188
      if (Z_ISREF_P(orig_object_ptr)
44150
188
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44151
188
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44152
0
        dim = RT_CONSTANT(opline, opline->op2);
44153
44154
0
        UNDEF_RESULT();
44155
188
      } else {
44156
188
        HashTable *ht = zend_new_array(8);
44157
188
        uint8_t old_type = Z_TYPE_P(object_ptr);
44158
44159
188
        ZVAL_ARR(object_ptr, ht);
44160
188
        if (UNEXPECTED(old_type == IS_FALSE)) {
44161
12
          GC_ADDREF(ht);
44162
12
          zend_false_to_array_deprecated();
44163
12
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44164
0
            zend_array_destroy(ht);
44165
0
            goto assign_dim_error;
44166
0
          }
44167
12
        }
44168
188
        goto try_assign_dim_array;
44169
188
      }
44170
188
    } else {
44171
15
      zend_use_scalar_as_array();
44172
15
      dim = RT_CONSTANT(opline, opline->op2);
44173
27
assign_dim_error:
44174
44175
27
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44176
17
        ZVAL_NULL(EX_VAR(opline->result.var));
44177
17
      }
44178
27
    }
44179
644
  }
44180
1.49k
  if (IS_CONST != IS_UNUSED) {
44181
44182
1.49k
  }
44183
44184
  /* assign_dim has two opcodes! */
44185
1.49k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44186
1.49k
}
44187
44188
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44189
328
{
44190
328
  USE_OPLINE
44191
328
  zval *object_ptr, *orig_object_ptr;
44192
328
  zval *value;
44193
328
  zval *variable_ptr;
44194
328
  zval *dim;
44195
328
  zend_refcounted *garbage = NULL;
44196
44197
328
  SAVE_OPLINE();
44198
328
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44199
44200
328
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44201
194
try_assign_dim_array:
44202
194
    SEPARATE_ARRAY(object_ptr);
44203
194
    if (IS_CONST == IS_UNUSED) {
44204
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44205
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44206
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
44207
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44208
0
          GC_ADDREF(ht);
44209
0
        }
44210
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44211
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44212
0
          zend_array_destroy(ht);
44213
0
          goto assign_dim_error;
44214
0
        }
44215
0
      }
44216
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
44217
0
        ZVAL_DEREF(value);
44218
0
      }
44219
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44220
0
      if (UNEXPECTED(value == NULL)) {
44221
0
        zend_cannot_add_element();
44222
0
        goto assign_dim_error;
44223
0
      } else if (IS_TMP_VAR == IS_CV) {
44224
0
        if (Z_REFCOUNTED_P(value)) {
44225
0
          Z_ADDREF_P(value);
44226
0
        }
44227
0
      } else if (IS_TMP_VAR == IS_VAR) {
44228
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
44229
0
        if (Z_ISREF_P(free_op_data)) {
44230
0
          if (Z_REFCOUNTED_P(value)) {
44231
0
            Z_ADDREF_P(value);
44232
0
          }
44233
0
          zval_ptr_dtor_nogc(free_op_data);
44234
0
        }
44235
0
      } else if (IS_TMP_VAR == IS_CONST) {
44236
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44237
0
          Z_ADDREF_P(value);
44238
0
        }
44239
0
      }
44240
194
    } else {
44241
194
      dim = RT_CONSTANT(opline, opline->op2);
44242
194
      if (IS_CONST == IS_CONST) {
44243
194
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44244
194
      } else {
44245
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44246
0
      }
44247
194
      if (UNEXPECTED(variable_ptr == NULL)) {
44248
0
        goto assign_dim_error;
44249
0
      }
44250
194
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44251
194
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
44252
194
    }
44253
194
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44254
111
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44255
111
    }
44256
194
    if (garbage) {
44257
0
      GC_DTOR_NO_REF(garbage);
44258
0
    }
44259
199
  } else {
44260
199
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
44261
36
      object_ptr = Z_REFVAL_P(object_ptr);
44262
36
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44263
36
        goto try_assign_dim_array;
44264
36
      }
44265
36
    }
44266
163
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44267
80
      zend_object *obj = Z_OBJ_P(object_ptr);
44268
44269
80
      GC_ADDREF(obj);
44270
80
      dim = RT_CONSTANT(opline, opline->op2);
44271
80
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44272
0
        dim = ZVAL_UNDEFINED_OP2();
44273
80
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44274
0
        dim++;
44275
0
      }
44276
44277
80
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44278
80
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44279
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44280
80
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
44281
0
        ZVAL_DEREF(value);
44282
0
      }
44283
44284
80
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44285
44286
80
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44287
80
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44288
0
        zend_objects_store_del(obj);
44289
0
      }
44290
83
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44291
54
      if (IS_CONST == IS_UNUSED) {
44292
0
        zend_use_new_element_for_string();
44293
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44294
0
        UNDEF_RESULT();
44295
54
      } else {
44296
54
        dim = RT_CONSTANT(opline, opline->op2);
44297
54
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44298
54
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44299
54
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44300
54
      }
44301
54
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44302
29
      if (Z_ISREF_P(orig_object_ptr)
44303
29
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44304
29
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44305
0
        dim = RT_CONSTANT(opline, opline->op2);
44306
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44307
0
        UNDEF_RESULT();
44308
29
      } else {
44309
29
        HashTable *ht = zend_new_array(8);
44310
29
        uint8_t old_type = Z_TYPE_P(object_ptr);
44311
44312
29
        ZVAL_ARR(object_ptr, ht);
44313
29
        if (UNEXPECTED(old_type == IS_FALSE)) {
44314
0
          GC_ADDREF(ht);
44315
0
          zend_false_to_array_deprecated();
44316
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44317
0
            zend_array_destroy(ht);
44318
0
            goto assign_dim_error;
44319
0
          }
44320
0
        }
44321
29
        goto try_assign_dim_array;
44322
29
      }
44323
29
    } else {
44324
0
      zend_use_scalar_as_array();
44325
0
      dim = RT_CONSTANT(opline, opline->op2);
44326
0
assign_dim_error:
44327
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44328
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44329
0
        ZVAL_NULL(EX_VAR(opline->result.var));
44330
0
      }
44331
0
    }
44332
163
  }
44333
328
  if (IS_CONST != IS_UNUSED) {
44334
44335
328
  }
44336
44337
  /* assign_dim has two opcodes! */
44338
328
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44339
328
}
44340
44341
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44342
453
{
44343
453
  USE_OPLINE
44344
453
  zval *object_ptr, *orig_object_ptr;
44345
453
  zval *value;
44346
453
  zval *variable_ptr;
44347
453
  zval *dim;
44348
453
  zend_refcounted *garbage = NULL;
44349
44350
453
  SAVE_OPLINE();
44351
453
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44352
44353
453
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44354
435
try_assign_dim_array:
44355
435
    SEPARATE_ARRAY(object_ptr);
44356
435
    if (IS_CONST == IS_UNUSED) {
44357
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44358
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44359
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
44360
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44361
0
          GC_ADDREF(ht);
44362
0
        }
44363
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44364
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44365
0
          zend_array_destroy(ht);
44366
0
          goto assign_dim_error;
44367
0
        }
44368
0
      }
44369
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
44370
0
        ZVAL_DEREF(value);
44371
0
      }
44372
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44373
0
      if (UNEXPECTED(value == NULL)) {
44374
0
        zend_cannot_add_element();
44375
0
        goto assign_dim_error;
44376
0
      } else if (IS_VAR == IS_CV) {
44377
0
        if (Z_REFCOUNTED_P(value)) {
44378
0
          Z_ADDREF_P(value);
44379
0
        }
44380
0
      } else if (IS_VAR == IS_VAR) {
44381
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
44382
0
        if (Z_ISREF_P(free_op_data)) {
44383
0
          if (Z_REFCOUNTED_P(value)) {
44384
0
            Z_ADDREF_P(value);
44385
0
          }
44386
0
          zval_ptr_dtor_nogc(free_op_data);
44387
0
        }
44388
0
      } else if (IS_VAR == IS_CONST) {
44389
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44390
0
          Z_ADDREF_P(value);
44391
0
        }
44392
0
      }
44393
435
    } else {
44394
435
      dim = RT_CONSTANT(opline, opline->op2);
44395
435
      if (IS_CONST == IS_CONST) {
44396
435
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44397
435
      } else {
44398
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44399
0
      }
44400
435
      if (UNEXPECTED(variable_ptr == NULL)) {
44401
0
        goto assign_dim_error;
44402
0
      }
44403
435
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44404
435
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
44405
435
    }
44406
435
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44407
10
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44408
10
    }
44409
435
    if (garbage) {
44410
311
      GC_DTOR_NO_REF(garbage);
44411
311
    }
44412
435
  } else {
44413
57
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
44414
0
      object_ptr = Z_REFVAL_P(object_ptr);
44415
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44416
0
        goto try_assign_dim_array;
44417
0
      }
44418
0
    }
44419
57
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44420
18
      zend_object *obj = Z_OBJ_P(object_ptr);
44421
44422
18
      GC_ADDREF(obj);
44423
18
      dim = RT_CONSTANT(opline, opline->op2);
44424
18
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44425
0
        dim = ZVAL_UNDEFINED_OP2();
44426
18
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44427
0
        dim++;
44428
0
      }
44429
44430
18
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44431
18
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44432
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44433
18
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
44434
18
        ZVAL_DEREF(value);
44435
18
      }
44436
44437
18
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44438
44439
18
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44440
18
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44441
0
        zend_objects_store_del(obj);
44442
0
      }
44443
39
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44444
0
      if (IS_CONST == IS_UNUSED) {
44445
0
        zend_use_new_element_for_string();
44446
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44447
0
        UNDEF_RESULT();
44448
0
      } else {
44449
0
        dim = RT_CONSTANT(opline, opline->op2);
44450
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44451
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44452
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44453
0
      }
44454
39
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44455
39
      if (Z_ISREF_P(orig_object_ptr)
44456
39
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44457
39
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44458
0
        dim = RT_CONSTANT(opline, opline->op2);
44459
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44460
0
        UNDEF_RESULT();
44461
39
      } else {
44462
39
        HashTable *ht = zend_new_array(8);
44463
39
        uint8_t old_type = Z_TYPE_P(object_ptr);
44464
44465
39
        ZVAL_ARR(object_ptr, ht);
44466
39
        if (UNEXPECTED(old_type == IS_FALSE)) {
44467
0
          GC_ADDREF(ht);
44468
0
          zend_false_to_array_deprecated();
44469
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44470
0
            zend_array_destroy(ht);
44471
0
            goto assign_dim_error;
44472
0
          }
44473
0
        }
44474
39
        goto try_assign_dim_array;
44475
39
      }
44476
39
    } else {
44477
0
      zend_use_scalar_as_array();
44478
0
      dim = RT_CONSTANT(opline, opline->op2);
44479
0
assign_dim_error:
44480
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44481
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44482
0
        ZVAL_NULL(EX_VAR(opline->result.var));
44483
0
      }
44484
0
    }
44485
57
  }
44486
453
  if (IS_CONST != IS_UNUSED) {
44487
44488
453
  }
44489
44490
  /* assign_dim has two opcodes! */
44491
453
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44492
453
}
44493
44494
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44495
971
{
44496
971
  USE_OPLINE
44497
971
  zval *object_ptr, *orig_object_ptr;
44498
971
  zval *value;
44499
971
  zval *variable_ptr;
44500
971
  zval *dim;
44501
971
  zend_refcounted *garbage = NULL;
44502
44503
971
  SAVE_OPLINE();
44504
971
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44505
44506
971
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44507
670
try_assign_dim_array:
44508
670
    SEPARATE_ARRAY(object_ptr);
44509
670
    if (IS_CONST == IS_UNUSED) {
44510
0
      value = EX_VAR((opline+1)->op1.var);
44511
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44512
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
44513
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44514
0
          GC_ADDREF(ht);
44515
0
        }
44516
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44517
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44518
0
          zend_array_destroy(ht);
44519
0
          goto assign_dim_error;
44520
0
        }
44521
0
      }
44522
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
44523
0
        ZVAL_DEREF(value);
44524
0
      }
44525
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44526
0
      if (UNEXPECTED(value == NULL)) {
44527
0
        zend_cannot_add_element();
44528
0
        goto assign_dim_error;
44529
0
      } else if (IS_CV == IS_CV) {
44530
0
        if (Z_REFCOUNTED_P(value)) {
44531
0
          Z_ADDREF_P(value);
44532
0
        }
44533
0
      } else if (IS_CV == IS_VAR) {
44534
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
44535
0
        if (Z_ISREF_P(free_op_data)) {
44536
0
          if (Z_REFCOUNTED_P(value)) {
44537
0
            Z_ADDREF_P(value);
44538
0
          }
44539
0
          zval_ptr_dtor_nogc(free_op_data);
44540
0
        }
44541
0
      } else if (IS_CV == IS_CONST) {
44542
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44543
0
          Z_ADDREF_P(value);
44544
0
        }
44545
0
      }
44546
670
    } else {
44547
670
      dim = RT_CONSTANT(opline, opline->op2);
44548
670
      if (IS_CONST == IS_CONST) {
44549
670
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44550
670
      } else {
44551
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44552
0
      }
44553
670
      if (UNEXPECTED(variable_ptr == NULL)) {
44554
0
        goto assign_dim_error;
44555
0
      }
44556
670
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
44557
670
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
44558
670
    }
44559
670
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44560
490
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44561
490
    }
44562
670
    if (garbage) {
44563
279
      GC_DTOR_NO_REF(garbage);
44564
279
    }
44565
670
  } else {
44566
463
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
44567
5
      object_ptr = Z_REFVAL_P(object_ptr);
44568
5
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44569
5
        goto try_assign_dim_array;
44570
5
      }
44571
5
    }
44572
458
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44573
147
      zend_object *obj = Z_OBJ_P(object_ptr);
44574
44575
147
      GC_ADDREF(obj);
44576
147
      dim = RT_CONSTANT(opline, opline->op2);
44577
147
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44578
0
        dim = ZVAL_UNDEFINED_OP2();
44579
147
      } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44580
0
        dim++;
44581
0
      }
44582
44583
147
      value = EX_VAR((opline+1)->op1.var);
44584
147
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44585
34
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44586
113
      } else if (IS_CV & (IS_CV|IS_VAR)) {
44587
113
        ZVAL_DEREF(value);
44588
113
      }
44589
44590
147
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44591
44592
147
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44593
0
        zend_objects_store_del(obj);
44594
0
      }
44595
311
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44596
94
      if (IS_CONST == IS_UNUSED) {
44597
0
        zend_use_new_element_for_string();
44598
44599
0
        UNDEF_RESULT();
44600
94
      } else {
44601
94
        dim = RT_CONSTANT(opline, opline->op2);
44602
94
        value = EX_VAR((opline+1)->op1.var);
44603
94
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44604
44605
94
      }
44606
217
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44607
157
      if (Z_ISREF_P(orig_object_ptr)
44608
157
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44609
157
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44610
0
        dim = RT_CONSTANT(opline, opline->op2);
44611
44612
0
        UNDEF_RESULT();
44613
157
      } else {
44614
157
        HashTable *ht = zend_new_array(8);
44615
157
        uint8_t old_type = Z_TYPE_P(object_ptr);
44616
44617
157
        ZVAL_ARR(object_ptr, ht);
44618
157
        if (UNEXPECTED(old_type == IS_FALSE)) {
44619
15
          GC_ADDREF(ht);
44620
15
          zend_false_to_array_deprecated();
44621
15
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44622
0
            zend_array_destroy(ht);
44623
0
            goto assign_dim_error;
44624
0
          }
44625
15
        }
44626
157
        goto try_assign_dim_array;
44627
157
      }
44628
157
    } else {
44629
60
      zend_use_scalar_as_array();
44630
60
      dim = RT_CONSTANT(opline, opline->op2);
44631
60
assign_dim_error:
44632
44633
60
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44634
0
        ZVAL_NULL(EX_VAR(opline->result.var));
44635
0
      }
44636
60
    }
44637
458
  }
44638
971
  if (IS_CONST != IS_UNUSED) {
44639
44640
971
  }
44641
44642
  /* assign_dim has two opcodes! */
44643
971
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44644
971
}
44645
44646
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44647
583k
{
44648
583k
  USE_OPLINE
44649
583k
  zval *value;
44650
583k
  zval *variable_ptr;
44651
44652
583k
  SAVE_OPLINE();
44653
583k
  value = RT_CONSTANT(opline, opline->op2);
44654
583k
  variable_ptr = EX_VAR(opline->op1.var);
44655
44656
583k
  if (0 || UNEXPECTED(0)) {
44657
0
    zend_refcounted *garbage = NULL;
44658
44659
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44660
0
    if (UNEXPECTED(0)) {
44661
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44662
0
    }
44663
0
    if (garbage) {
44664
0
      GC_DTOR_NO_REF(garbage);
44665
0
    }
44666
583k
  } else {
44667
583k
    value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
44668
583k
  }
44669
44670
  /* zend_assign_to_variable() always takes care of op2, never free it! */
44671
44672
583k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44673
583k
}
44674
44675
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44676
603k
{
44677
603k
  USE_OPLINE
44678
603k
  zval *value;
44679
603k
  zval *variable_ptr;
44680
44681
603k
  SAVE_OPLINE();
44682
603k
  value = RT_CONSTANT(opline, opline->op2);
44683
603k
  variable_ptr = EX_VAR(opline->op1.var);
44684
44685
603k
  if (0 || UNEXPECTED(1)) {
44686
603k
    zend_refcounted *garbage = NULL;
44687
44688
603k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44689
603k
    if (UNEXPECTED(1)) {
44690
603k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
44691
603k
    }
44692
603k
    if (garbage) {
44693
15.0k
      GC_DTOR_NO_REF(garbage);
44694
15.0k
    }
44695
603k
  } else {
44696
0
    value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
44697
0
  }
44698
44699
  /* zend_assign_to_variable() always takes care of op2, never free it! */
44700
44701
603k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44702
603k
}
44703
44704
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44705
88
{
44706
88
  USE_OPLINE
44707
88
  zval *property, *container, *value_ptr;
44708
44709
88
  SAVE_OPLINE();
44710
44711
88
  container = EX_VAR(opline->op1.var);
44712
88
  property = RT_CONSTANT(opline, opline->op2);
44713
44714
88
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44715
44716
88
  if (1) {
44717
88
    if (IS_CV == IS_UNUSED) {
44718
0
      if (IS_CONST == IS_CONST) {
44719
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44720
0
      } else {
44721
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44722
0
      }
44723
88
    } else {
44724
88
      if (IS_CONST == IS_CONST) {
44725
88
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44726
88
      } else {
44727
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44728
0
      }
44729
88
    }
44730
88
  } else {
44731
0
    zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44732
0
  }
44733
44734
44735
88
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44736
88
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44737
88
}
44738
44739
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
44740
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44741
251
{
44742
251
  USE_OPLINE
44743
251
  zval *property, *container, *value_ptr;
44744
44745
251
  SAVE_OPLINE();
44746
44747
251
  container = EX_VAR(opline->op1.var);
44748
251
  property = RT_CONSTANT(opline, opline->op2);
44749
44750
251
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
44751
44752
251
  if (1) {
44753
251
    if (IS_CV == IS_UNUSED) {
44754
0
      if (IS_CONST == IS_CONST) {
44755
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44756
0
      } else {
44757
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44758
0
      }
44759
251
    } else {
44760
251
      if (IS_CONST == IS_CONST) {
44761
251
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44762
251
      } else {
44763
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44764
0
      }
44765
251
    }
44766
251
  } else {
44767
0
    zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44768
0
  }
44769
44770
44771
44772
251
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
44773
251
}
44774
44775
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
44776
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44777
86.2k
{
44778
86.2k
  USE_OPLINE
44779
86.2k
  zval *op1, *op2;
44780
86.2k
  zend_string *op1_str, *op2_str, *str;
44781
44782
44783
86.2k
  op1 = EX_VAR(opline->op1.var);
44784
86.2k
  op2 = RT_CONSTANT(opline, opline->op2);
44785
86.2k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
44786
86.2k
      (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
44787
1.41k
    zend_string *op1_str = Z_STR_P(op1);
44788
1.41k
    zend_string *op2_str = Z_STR_P(op2);
44789
1.41k
    zend_string *str;
44790
1.41k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
44791
44792
1.41k
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44793
107
      if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
44794
107
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
44795
107
      } else {
44796
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44797
0
      }
44798
107
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44799
0
        zend_string_release_ex(op1_str, 0);
44800
0
      }
44801
1.30k
    } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44802
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
44803
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
44804
0
      } else {
44805
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44806
0
      }
44807
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44808
0
        zend_string_release_ex(op2_str, 0);
44809
0
      }
44810
1.30k
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
44811
1.30k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
44812
0
      size_t len = ZSTR_LEN(op1_str);
44813
44814
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
44815
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44816
0
      GC_ADD_FLAGS(str, flags);
44817
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44818
0
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44819
0
        zend_string_release_ex(op2_str, 0);
44820
0
      }
44821
1.30k
    } else {
44822
1.30k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44823
1.30k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44824
1.30k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44825
1.30k
      GC_ADD_FLAGS(str, flags);
44826
1.30k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44827
1.30k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44828
0
        zend_string_release_ex(op1_str, 0);
44829
0
      }
44830
1.30k
      if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44831
0
        zend_string_release_ex(op2_str, 0);
44832
0
      }
44833
1.30k
    }
44834
1.41k
    ZEND_VM_NEXT_OPCODE();
44835
1.41k
  }
44836
44837
86.2k
  SAVE_OPLINE();
44838
84.8k
  if (IS_CV == IS_CONST) {
44839
0
    op1_str = Z_STR_P(op1);
44840
84.8k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44841
0
    op1_str = zend_string_copy(Z_STR_P(op1));
44842
84.8k
  } else {
44843
84.8k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44844
80.2k
      ZVAL_UNDEFINED_OP1();
44845
80.2k
    }
44846
84.8k
    op1_str = zval_get_string_func(op1);
44847
84.8k
  }
44848
84.8k
  if (IS_CONST == IS_CONST) {
44849
84.8k
    op2_str = Z_STR_P(op2);
44850
84.8k
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44851
0
    op2_str = zend_string_copy(Z_STR_P(op2));
44852
0
  } else {
44853
0
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
44854
0
      ZVAL_UNDEFINED_OP2();
44855
0
    }
44856
0
    op2_str = zval_get_string_func(op2);
44857
0
  }
44858
84.8k
  do {
44859
84.8k
    if (IS_CV != IS_CONST) {
44860
84.8k
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44861
80.4k
        if (IS_CONST == IS_CONST) {
44862
80.4k
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
44863
0
            GC_ADDREF(op2_str);
44864
0
          }
44865
80.4k
        }
44866
80.4k
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44867
80.4k
        zend_string_release_ex(op1_str, 0);
44868
80.4k
        break;
44869
80.4k
      }
44870
84.8k
    }
44871
4.39k
    if (IS_CONST != IS_CONST) {
44872
0
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44873
0
        if (IS_CV == IS_CONST) {
44874
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
44875
0
            GC_ADDREF(op1_str);
44876
0
          }
44877
0
        }
44878
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44879
0
        zend_string_release_ex(op2_str, 0);
44880
0
        break;
44881
0
      }
44882
0
    }
44883
4.39k
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44884
4.39k
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44885
4.39k
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44886
44887
4.39k
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
44888
4.39k
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44889
4.39k
    if (IS_CV != IS_CONST) {
44890
4.39k
      zend_string_release_ex(op1_str, 0);
44891
4.39k
    }
44892
4.39k
    if (IS_CONST != IS_CONST) {
44893
0
      zend_string_release_ex(op2_str, 0);
44894
0
    }
44895
4.39k
  } while (0);
44896
44897
44898
84.8k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44899
84.8k
}
44900
44901
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44902
102k
{
44903
102k
  USE_OPLINE
44904
102k
  zval *function_name;
44905
102k
  zval *object;
44906
102k
  zend_function *fbc;
44907
102k
  zend_class_entry *called_scope;
44908
102k
  zend_object *obj;
44909
102k
  zend_execute_data *call;
44910
102k
  uint32_t call_info;
44911
44912
102k
  SAVE_OPLINE();
44913
44914
102k
  object = EX_VAR(opline->op1.var);
44915
44916
102k
  if (IS_CONST != IS_CONST) {
44917
0
    function_name = RT_CONSTANT(opline, opline->op2);
44918
0
  }
44919
44920
102k
  if (IS_CONST != IS_CONST &&
44921
102k
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
44922
0
    do {
44923
0
      if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
44924
0
        function_name = Z_REFVAL_P(function_name);
44925
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
44926
0
          break;
44927
0
        }
44928
0
      } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
44929
0
        ZVAL_UNDEFINED_OP2();
44930
0
        if (UNEXPECTED(EG(exception) != NULL)) {
44931
44932
0
          HANDLE_EXCEPTION();
44933
0
        }
44934
0
      }
44935
0
      zend_throw_error(NULL, "Method name must be a string");
44936
44937
44938
0
      HANDLE_EXCEPTION();
44939
0
    } while (0);
44940
0
  }
44941
44942
102k
  if (IS_CV == IS_UNUSED) {
44943
0
    obj = Z_OBJ_P(object);
44944
102k
  } else {
44945
102k
    do {
44946
102k
      if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
44947
101k
        obj = Z_OBJ_P(object);
44948
101k
      } else {
44949
687
        if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
44950
208
          zend_reference *ref = Z_REF_P(object);
44951
44952
208
          object = &ref->val;
44953
208
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
44954
206
            obj = Z_OBJ_P(object);
44955
206
            if (IS_CV & IS_VAR) {
44956
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
44957
0
                efree_size(ref, sizeof(zend_reference));
44958
0
              } else {
44959
0
                Z_ADDREF_P(object);
44960
0
              }
44961
0
            }
44962
206
            break;
44963
206
          }
44964
208
        }
44965
481
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
44966
368
          object = ZVAL_UNDEFINED_OP1();
44967
368
          if (UNEXPECTED(EG(exception) != NULL)) {
44968
0
            if (IS_CONST != IS_CONST) {
44969
44970
0
            }
44971
0
            HANDLE_EXCEPTION();
44972
0
          }
44973
368
        }
44974
481
        if (IS_CONST == IS_CONST) {
44975
481
          function_name = RT_CONSTANT(opline, opline->op2);
44976
481
        }
44977
481
        zend_invalid_method_call(object, function_name);
44978
44979
44980
481
        HANDLE_EXCEPTION();
44981
481
      }
44982
102k
    } while (0);
44983
102k
  }
44984
44985
102k
  called_scope = obj->ce;
44986
44987
102k
  if (IS_CONST == IS_CONST &&
44988
102k
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
44989
9.92k
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
44990
92.2k
  } else {
44991
92.2k
    zend_object *orig_obj = obj;
44992
44993
92.2k
    if (IS_CONST == IS_CONST) {
44994
92.2k
      function_name = RT_CONSTANT(opline, opline->op2);
44995
92.2k
    }
44996
44997
    /* First, locate the function. */
44998
92.2k
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
44999
92.2k
    if (UNEXPECTED(fbc == NULL)) {
45000
279
      if (EXPECTED(!EG(exception))) {
45001
254
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
45002
254
      }
45003
45004
279
      if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
45005
0
        zend_objects_store_del(orig_obj);
45006
0
      }
45007
279
      HANDLE_EXCEPTION();
45008
279
    }
45009
91.9k
    if (IS_CONST == IS_CONST &&
45010
91.9k
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
45011
91.9k
        EXPECTED(obj == orig_obj)) {
45012
91.1k
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
45013
91.1k
    }
45014
91.9k
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
45015
0
      GC_ADDREF(obj); /* For $this pointer */
45016
0
      if (GC_DELREF(orig_obj) == 0) {
45017
0
        zend_objects_store_del(orig_obj);
45018
0
      }
45019
0
    }
45020
91.9k
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
45021
3.58k
      init_func_run_time_cache(&fbc->op_array);
45022
3.58k
    }
45023
91.9k
  }
45024
45025
101k
  if (IS_CONST != IS_CONST) {
45026
45027
0
  }
45028
45029
101k
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
45030
101k
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
45031
20
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
45032
0
      zend_objects_store_del(obj);
45033
0
      if (UNEXPECTED(EG(exception))) {
45034
0
        HANDLE_EXCEPTION();
45035
0
      }
45036
0
    }
45037
    /* call static method */
45038
20
    obj = (zend_object*)called_scope;
45039
20
    call_info = ZEND_CALL_NESTED_FUNCTION;
45040
101k
  } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
45041
101k
    if (IS_CV == IS_CV) {
45042
101k
      GC_ADDREF(obj); /* For $this pointer */
45043
101k
    }
45044
    /* CV may be changed indirectly (e.g. when it's a reference) */
45045
101k
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
45046
101k
  }
45047
45048
101k
  call = zend_vm_stack_push_call_frame(call_info,
45049
101k
    fbc, opline->extended_value, obj);
45050
101k
  call->prev_execute_data = EX(call);
45051
101k
  EX(call) = call;
45052
45053
101k
  ZEND_VM_NEXT_OPCODE();
45054
101k
}
45055
45056
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45057
207
{
45058
207
  USE_OPLINE
45059
207
  zval *varptr, *arg;
45060
45061
207
  if (IS_CONST == IS_CONST) {
45062
207
    SAVE_OPLINE();
45063
207
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45064
207
    uint32_t arg_num;
45065
207
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45066
207
    if (UNEXPECTED(!arg)) {
45067
45068
0
      HANDLE_EXCEPTION();
45069
0
    }
45070
207
  } else {
45071
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45072
0
  }
45073
45074
207
  varptr = EX_VAR(opline->op1.var);
45075
207
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
45076
6
    SAVE_OPLINE();
45077
6
    ZVAL_UNDEFINED_OP1();
45078
6
    ZVAL_NULL(arg);
45079
6
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45080
6
  }
45081
45082
201
  if (IS_CV == IS_CV) {
45083
201
    ZVAL_COPY_DEREF(arg, varptr);
45084
201
  } else /* if (IS_CV == IS_VAR) */ {
45085
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
45086
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
45087
45088
0
      varptr = Z_REFVAL_P(varptr);
45089
0
      ZVAL_COPY_VALUE(arg, varptr);
45090
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45091
0
        efree_size(ref, sizeof(zend_reference));
45092
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
45093
0
        Z_ADDREF_P(arg);
45094
0
      }
45095
0
    } else {
45096
0
      ZVAL_COPY_VALUE(arg, varptr);
45097
0
    }
45098
0
  }
45099
45100
201
  ZEND_VM_NEXT_OPCODE();
45101
201
}
45102
45103
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45104
77
{
45105
77
  USE_OPLINE
45106
77
  zval *varptr, *arg;
45107
45108
77
  SAVE_OPLINE();
45109
77
  if (IS_CONST == IS_CONST) {
45110
77
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45111
77
    uint32_t arg_num;
45112
77
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45113
77
    if (UNEXPECTED(!arg)) {
45114
45115
0
      HANDLE_EXCEPTION();
45116
0
    }
45117
77
  } else {
45118
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45119
0
  }
45120
45121
77
  varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45122
77
  if (Z_ISREF_P(varptr)) {
45123
70
    Z_ADDREF_P(varptr);
45124
70
  } else {
45125
7
    ZVAL_MAKE_REF_EX(varptr, 2);
45126
7
  }
45127
77
  ZVAL_REF(arg, Z_REF_P(varptr));
45128
45129
77
  ZEND_VM_NEXT_OPCODE();
45130
77
}
45131
45132
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45133
425
{
45134
425
  USE_OPLINE
45135
425
  zval *varptr, *arg;
45136
425
  uint32_t arg_num;
45137
45138
425
  if (IS_CONST == IS_CONST) {
45139
425
    SAVE_OPLINE();
45140
425
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45141
425
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45142
425
    if (UNEXPECTED(!arg)) {
45143
45144
9
      HANDLE_EXCEPTION();
45145
9
    }
45146
425
  } else {
45147
0
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45148
0
    arg_num = opline->op2.num;
45149
0
  }
45150
45151
416
  if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
45152
370
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
45153
64
      goto send_var_by_ref;
45154
64
    }
45155
370
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
45156
91
send_var_by_ref:
45157
91
    varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45158
91
    if (Z_ISREF_P(varptr)) {
45159
12
      Z_ADDREF_P(varptr);
45160
79
    } else {
45161
79
      ZVAL_MAKE_REF_EX(varptr, 2);
45162
79
    }
45163
91
    ZVAL_REF(arg, Z_REF_P(varptr));
45164
45165
91
    ZEND_VM_NEXT_OPCODE();
45166
91
  }
45167
45168
325
  varptr = EX_VAR(opline->op1.var);
45169
325
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
45170
8
    SAVE_OPLINE();
45171
8
    ZVAL_UNDEFINED_OP1();
45172
8
    ZVAL_NULL(arg);
45173
8
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45174
8
  }
45175
45176
317
  if (IS_CV == IS_CV) {
45177
317
    ZVAL_COPY_DEREF(arg, varptr);
45178
317
  } else /* if (IS_CV == IS_VAR) */ {
45179
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
45180
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
45181
45182
0
      varptr = Z_REFVAL_P(varptr);
45183
0
      ZVAL_COPY_VALUE(arg, varptr);
45184
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45185
0
        efree_size(ref, sizeof(zend_reference));
45186
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
45187
0
        Z_ADDREF_P(arg);
45188
0
      }
45189
0
    } else {
45190
0
      ZVAL_COPY_VALUE(arg, varptr);
45191
0
    }
45192
0
  }
45193
45194
317
  ZEND_VM_NEXT_OPCODE();
45195
317
}
45196
45197
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45198
256
{
45199
256
  USE_OPLINE
45200
256
  zval *expr_ptr, new_expr;
45201
45202
256
  SAVE_OPLINE();
45203
256
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
45204
256
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
45205
23
    expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45206
23
    if (Z_ISREF_P(expr_ptr)) {
45207
0
      Z_ADDREF_P(expr_ptr);
45208
23
    } else {
45209
23
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
45210
23
    }
45211
45212
233
  } else {
45213
233
    expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45214
233
    if (IS_CV == IS_TMP_VAR) {
45215
      /* pass */
45216
233
    } else if (IS_CV == IS_CONST) {
45217
0
      Z_TRY_ADDREF_P(expr_ptr);
45218
233
    } else if (IS_CV == IS_CV) {
45219
233
      ZVAL_DEREF(expr_ptr);
45220
233
      Z_TRY_ADDREF_P(expr_ptr);
45221
233
    } else /* if (IS_CV == IS_VAR) */ {
45222
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
45223
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
45224
45225
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
45226
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45227
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
45228
0
          expr_ptr = &new_expr;
45229
0
          efree_size(ref, sizeof(zend_reference));
45230
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
45231
0
          Z_ADDREF_P(expr_ptr);
45232
0
        }
45233
0
      }
45234
0
    }
45235
233
  }
45236
45237
256
  if (IS_CONST != IS_UNUSED) {
45238
256
    zval *offset = RT_CONSTANT(opline, opline->op2);
45239
256
    zend_string *str;
45240
256
    zend_ulong hval;
45241
45242
256
add_again:
45243
256
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45244
246
      str = Z_STR_P(offset);
45245
246
      if (IS_CONST != IS_CONST) {
45246
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
45247
0
          goto num_index;
45248
0
        }
45249
0
      }
45250
246
str_index:
45251
246
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
45252
246
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45253
2
      hval = Z_LVAL_P(offset);
45254
4
num_index:
45255
4
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
45256
8
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
45257
0
      offset = Z_REFVAL_P(offset);
45258
0
      goto add_again;
45259
8
    } else if (Z_TYPE_P(offset) == IS_NULL) {
45260
0
      str = ZSTR_EMPTY_ALLOC();
45261
0
      goto str_index;
45262
8
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
45263
2
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
45264
2
      goto num_index;
45265
6
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
45266
0
      hval = 0;
45267
0
      goto num_index;
45268
6
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
45269
0
      hval = 1;
45270
0
      goto num_index;
45271
6
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
45272
0
      zend_use_resource_as_offset(offset);
45273
0
      hval = Z_RES_HANDLE_P(offset);
45274
0
      goto num_index;
45275
6
    } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
45276
0
      ZVAL_UNDEFINED_OP2();
45277
0
      str = ZSTR_EMPTY_ALLOC();
45278
0
      goto str_index;
45279
6
    } else {
45280
6
      zend_illegal_array_offset_access(offset);
45281
6
      zval_ptr_dtor_nogc(expr_ptr);
45282
6
    }
45283
45284
256
  } else {
45285
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
45286
0
      zend_cannot_add_element();
45287
0
      zval_ptr_dtor_nogc(expr_ptr);
45288
0
    }
45289
0
  }
45290
256
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45291
256
}
45292
45293
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45294
143
{
45295
143
  zval *array;
45296
143
  uint32_t size;
45297
143
  USE_OPLINE
45298
45299
143
  SAVE_OPLINE();
45300
143
  array = EX_VAR(opline->result.var);
45301
143
  if (IS_CV != IS_UNUSED) {
45302
143
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
45303
143
    ZVAL_ARR(array, zend_new_array(size));
45304
    /* Explicitly initialize array as not-packed if flag is set */
45305
143
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
45306
133
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
45307
133
    }
45308
143
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45309
143
  } else {
45310
0
    ZVAL_ARR(array, zend_new_array(0));
45311
0
    ZEND_VM_NEXT_OPCODE();
45312
0
  }
45313
143
}
45314
45315
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45316
1.09k
{
45317
1.09k
  USE_OPLINE
45318
1.09k
  zval *container;
45319
1.09k
  zval *offset;
45320
1.09k
  zend_ulong hval;
45321
1.09k
  zend_string *key;
45322
45323
1.09k
  SAVE_OPLINE();
45324
1.09k
  container = EX_VAR(opline->op1.var);
45325
1.09k
  offset = RT_CONSTANT(opline, opline->op2);
45326
45327
1.09k
  do {
45328
1.09k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45329
421
      HashTable *ht;
45330
45331
598
unset_dim_array:
45332
598
      SEPARATE_ARRAY(container);
45333
598
      ht = Z_ARRVAL_P(container);
45334
598
offset_again:
45335
598
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45336
323
        key = Z_STR_P(offset);
45337
323
        if (IS_CONST != IS_CONST) {
45338
0
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
45339
0
            goto num_index_dim;
45340
0
          }
45341
0
        }
45342
323
str_index_dim:
45343
323
        ZEND_ASSERT(ht != &EG(symbol_table));
45344
323
        zend_hash_del(ht, key);
45345
323
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45346
270
        hval = Z_LVAL_P(offset);
45347
270
num_index_dim:
45348
270
        zend_hash_index_del(ht, hval);
45349
270
      } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
45350
0
        offset = Z_REFVAL_P(offset);
45351
0
        goto offset_again;
45352
5
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
45353
0
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
45354
0
        goto num_index_dim;
45355
5
      } else if (Z_TYPE_P(offset) == IS_NULL) {
45356
0
        key = ZSTR_EMPTY_ALLOC();
45357
0
        goto str_index_dim;
45358
5
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
45359
0
        hval = 0;
45360
0
        goto num_index_dim;
45361
5
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
45362
0
        hval = 1;
45363
0
        goto num_index_dim;
45364
5
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
45365
0
        zend_use_resource_as_offset(offset);
45366
0
        hval = Z_RES_HANDLE_P(offset);
45367
0
        goto num_index_dim;
45368
5
      } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
45369
0
        ZVAL_UNDEFINED_OP2();
45370
0
        key = ZSTR_EMPTY_ALLOC();
45371
0
        goto str_index_dim;
45372
5
      } else {
45373
5
        zend_illegal_array_offset_unset(offset);
45374
5
      }
45375
598
      break;
45376
670
    } else if (Z_ISREF_P(container)) {
45377
177
      container = Z_REFVAL_P(container);
45378
177
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45379
177
        goto unset_dim_array;
45380
177
      }
45381
177
    }
45382
493
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45383
353
      container = ZVAL_UNDEFINED_OP1();
45384
353
    }
45385
493
    if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
45386
0
      offset = ZVAL_UNDEFINED_OP2();
45387
0
    }
45388
493
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45389
85
      if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
45390
52
        offset++;
45391
52
      }
45392
85
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
45393
408
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
45394
5
      zend_throw_error(NULL, "Cannot unset string offsets");
45395
403
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
45396
22
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
45397
381
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
45398
15
      zend_false_to_array_deprecated();
45399
15
    }
45400
493
  } while (0);
45401
45402
45403
1.09k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45404
1.09k
}
45405
45406
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45407
625
{
45408
625
  USE_OPLINE
45409
625
  zval *container;
45410
625
  zval *offset;
45411
625
  zend_string *name, *tmp_name;
45412
45413
625
  SAVE_OPLINE();
45414
625
  container = EX_VAR(opline->op1.var);
45415
625
  offset = RT_CONSTANT(opline, opline->op2);
45416
45417
625
  do {
45418
625
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
45419
103
      if (Z_ISREF_P(container)) {
45420
2
        container = Z_REFVAL_P(container);
45421
2
        if (Z_TYPE_P(container) != IS_OBJECT) {
45422
2
          if (IS_CV == IS_CV
45423
2
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45424
0
            ZVAL_UNDEFINED_OP1();
45425
0
          }
45426
2
          break;
45427
2
        }
45428
101
      } else {
45429
101
        break;
45430
101
      }
45431
103
    }
45432
522
    if (IS_CONST == IS_CONST) {
45433
522
      name = Z_STR_P(offset);
45434
522
    } else {
45435
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
45436
0
      if (UNEXPECTED(!name)) {
45437
0
        break;
45438
0
      }
45439
0
    }
45440
522
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
45441
522
    if (IS_CONST != IS_CONST) {
45442
0
      zend_tmp_string_release(tmp_name);
45443
0
    }
45444
522
  } while (0);
45445
45446
45447
625
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45448
625
}
45449
45450
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45451
1.14k
{
45452
1.14k
  USE_OPLINE
45453
1.14k
  zval *container;
45454
1.14k
  bool result;
45455
1.14k
  zend_ulong hval;
45456
1.14k
  zval *offset;
45457
45458
1.14k
  SAVE_OPLINE();
45459
1.14k
  container = EX_VAR(opline->op1.var);
45460
1.14k
  offset = RT_CONSTANT(opline, opline->op2);
45461
45462
1.14k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45463
240
    HashTable *ht;
45464
240
    zval *value;
45465
240
    zend_string *str;
45466
45467
240
isset_dim_obj_array:
45468
240
    ht = Z_ARRVAL_P(container);
45469
240
isset_again:
45470
240
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45471
45
      str = Z_STR_P(offset);
45472
45
      if (IS_CONST != IS_CONST) {
45473
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
45474
0
          goto num_index_prop;
45475
0
        }
45476
0
      }
45477
45
      value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
45478
195
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45479
165
      hval = Z_LVAL_P(offset);
45480
165
num_index_prop:
45481
165
      value = zend_hash_index_find(ht, hval);
45482
165
    } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
45483
0
      offset = Z_REFVAL_P(offset);
45484
0
      goto isset_again;
45485
30
    } else {
45486
30
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
45487
30
      if (UNEXPECTED(EG(exception))) {
45488
10
        result = 0;
45489
10
        goto isset_dim_obj_exit;
45490
10
      }
45491
30
    }
45492
45493
230
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
45494
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
45495
218
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
45496
218
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
45497
45498
218
      if (IS_CV & (IS_CONST|IS_CV)) {
45499
        /* avoid exception check */
45500
45501
218
        ZEND_VM_SMART_BRANCH(result, 0);
45502
218
      }
45503
218
    } else {
45504
12
      result = (value == NULL || !i_zend_is_true(value));
45505
12
    }
45506
12
    goto isset_dim_obj_exit;
45507
901
  } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
45508
30
    container = Z_REFVAL_P(container);
45509
30
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45510
0
      goto isset_dim_obj_array;
45511
0
    }
45512
30
  }
45513
45514
901
  if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
45515
200
    offset++;
45516
200
  }
45517
901
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
45518
589
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
45519
589
  } else {
45520
312
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
45521
312
  }
45522
45523
923
isset_dim_obj_exit:
45524
45525
45526
923
  ZEND_VM_SMART_BRANCH(result, 1);
45527
923
}
45528
45529
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45530
464
{
45531
464
  USE_OPLINE
45532
464
  zval *container;
45533
464
  int result;
45534
464
  zval *offset;
45535
464
  zend_string *name, *tmp_name;
45536
45537
464
  SAVE_OPLINE();
45538
464
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
45539
464
  offset = RT_CONSTANT(opline, opline->op2);
45540
45541
464
  if (IS_CV == IS_CONST ||
45542
464
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
45543
151
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
45544
0
      container = Z_REFVAL_P(container);
45545
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
45546
0
        result = (opline->extended_value & ZEND_ISEMPTY);
45547
0
        goto isset_object_finish;
45548
0
      }
45549
151
    } else {
45550
151
      result = (opline->extended_value & ZEND_ISEMPTY);
45551
151
      goto isset_object_finish;
45552
151
    }
45553
151
  }
45554
45555
313
  if (IS_CONST == IS_CONST) {
45556
313
    name = Z_STR_P(offset);
45557
313
  } else {
45558
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
45559
0
    if (UNEXPECTED(!name)) {
45560
0
      result = 0;
45561
0
      goto isset_object_finish;
45562
0
    }
45563
0
  }
45564
45565
313
  result =
45566
313
    (opline->extended_value & ZEND_ISEMPTY) ^
45567
313
    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));
45568
45569
313
  if (IS_CONST != IS_CONST) {
45570
0
    zend_tmp_string_release(tmp_name);
45571
0
  }
45572
45573
464
isset_object_finish:
45574
45575
45576
464
  ZEND_VM_SMART_BRANCH(result, 1);
45577
464
}
45578
45579
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45580
0
{
45581
0
  USE_OPLINE
45582
45583
0
  zval *key, *subject;
45584
0
  HashTable *ht;
45585
0
  bool result;
45586
45587
0
  SAVE_OPLINE();
45588
45589
0
  key = EX_VAR(opline->op1.var);
45590
0
  subject = RT_CONSTANT(opline, opline->op2);
45591
45592
0
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
45593
0
array_key_exists_array:
45594
0
    ht = Z_ARRVAL_P(subject);
45595
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
45596
0
  } else {
45597
0
    if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
45598
0
      subject = Z_REFVAL_P(subject);
45599
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
45600
0
        goto array_key_exists_array;
45601
0
      }
45602
0
    }
45603
0
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
45604
0
    result = 0;
45605
0
  }
45606
45607
45608
0
  ZEND_VM_SMART_BRANCH(result, 1);
45609
0
}
45610
45611
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45612
236
{
45613
236
  USE_OPLINE
45614
236
  zval *expr;
45615
236
  bool result;
45616
45617
236
  SAVE_OPLINE();
45618
236
  expr = EX_VAR(opline->op1.var);
45619
45620
262
try_instanceof:
45621
262
  if (Z_TYPE_P(expr) == IS_OBJECT) {
45622
221
    zend_class_entry *ce;
45623
45624
221
    if (IS_CONST == IS_CONST) {
45625
221
      ce = CACHED_PTR(opline->extended_value);
45626
221
      if (UNEXPECTED(ce == NULL)) {
45627
37
        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);
45628
37
        if (EXPECTED(ce)) {
45629
32
          CACHE_PTR(opline->extended_value, ce);
45630
32
        }
45631
37
      }
45632
221
    } else if (IS_CONST == IS_UNUSED) {
45633
0
      ce = zend_fetch_class(NULL, opline->op2.num);
45634
0
      if (UNEXPECTED(ce == NULL)) {
45635
45636
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
45637
0
        HANDLE_EXCEPTION();
45638
0
      }
45639
0
    } else {
45640
0
      ce = Z_CE_P(EX_VAR(opline->op2.var));
45641
0
    }
45642
221
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
45643
221
  } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
45644
26
    expr = Z_REFVAL_P(expr);
45645
26
    goto try_instanceof;
45646
26
  } else {
45647
15
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
45648
3
      ZVAL_UNDEFINED_OP1();
45649
3
    }
45650
15
    result = 0;
45651
15
  }
45652
45653
236
  ZEND_VM_SMART_BRANCH(result, 1);
45654
236
}
45655
45656
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45657
0
{
45658
0
  USE_OPLINE
45659
45660
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
45661
45662
0
  SAVE_OPLINE();
45663
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
45664
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45665
0
  }
45666
45667
  /* Destroy the previously yielded value */
45668
0
  zval_ptr_dtor(&generator->value);
45669
45670
  /* Destroy the previously yielded key */
45671
0
  zval_ptr_dtor(&generator->key);
45672
45673
  /* Set the new yielded value */
45674
0
  if (IS_CV != IS_UNUSED) {
45675
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
45676
      /* Constants and temporary variables aren't yieldable by reference,
45677
       * but we still allow them with a notice. */
45678
0
      if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
45679
0
        zval *value;
45680
45681
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
45682
45683
0
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45684
0
        ZVAL_COPY_VALUE(&generator->value, value);
45685
0
        if (IS_CV == IS_CONST) {
45686
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
45687
0
            Z_ADDREF(generator->value);
45688
0
          }
45689
0
        }
45690
0
      } else {
45691
0
        zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45692
45693
        /* If a function call result is yielded and the function did
45694
         * not return by reference we throw a notice. */
45695
0
        do {
45696
0
          if (IS_CV == IS_VAR) {
45697
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
45698
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
45699
0
             && !Z_ISREF_P(value_ptr)) {
45700
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
45701
0
              ZVAL_COPY(&generator->value, value_ptr);
45702
0
              break;
45703
0
            }
45704
0
          }
45705
0
          if (Z_ISREF_P(value_ptr)) {
45706
0
            Z_ADDREF_P(value_ptr);
45707
0
          } else {
45708
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
45709
0
          }
45710
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
45711
0
        } while (0);
45712
45713
0
      }
45714
0
    } else {
45715
0
      zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45716
45717
      /* Consts, temporary variables and references need copying */
45718
0
      if (IS_CV == IS_CONST) {
45719
0
        ZVAL_COPY_VALUE(&generator->value, value);
45720
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
45721
0
          Z_ADDREF(generator->value);
45722
0
        }
45723
0
      } else if (IS_CV == IS_TMP_VAR) {
45724
0
        ZVAL_COPY_VALUE(&generator->value, value);
45725
0
      } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
45726
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
45727
45728
0
      } else {
45729
0
        ZVAL_COPY_VALUE(&generator->value, value);
45730
0
        if (IS_CV == IS_CV) {
45731
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
45732
0
        }
45733
0
      }
45734
0
    }
45735
0
  } else {
45736
    /* If no value was specified yield null */
45737
0
    ZVAL_NULL(&generator->value);
45738
0
  }
45739
45740
  /* Set the new yielded key */
45741
0
  if (IS_CONST != IS_UNUSED) {
45742
0
    zval *key = RT_CONSTANT(opline, opline->op2);
45743
0
    if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
45744
0
      key = Z_REFVAL_P(key);
45745
0
    }
45746
0
    ZVAL_COPY(&generator->key, key);
45747
45748
0
    if (Z_TYPE(generator->key) == IS_LONG
45749
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
45750
0
    ) {
45751
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
45752
0
    }
45753
0
  } else {
45754
    /* If no key was specified we use auto-increment keys */
45755
0
    generator->largest_used_integer_key++;
45756
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
45757
0
  }
45758
45759
0
  if (RETURN_VALUE_USED(opline)) {
45760
    /* If the return value of yield is used set the send
45761
     * target and initialize it to NULL */
45762
0
    generator->send_target = EX_VAR(opline->result.var);
45763
0
    ZVAL_NULL(generator->send_target);
45764
0
  } else {
45765
0
    generator->send_target = NULL;
45766
0
  }
45767
45768
  /* The GOTO VM uses a local opline variable. We need to set the opline
45769
   * variable in execute_data so we don't resume at an old position. */
45770
0
  SAVE_OPLINE();
45771
45772
0
  ZEND_VM_RETURN();
45773
0
}
45774
45775
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45776
2.45k
{
45777
2.45k
  USE_OPLINE
45778
2.45k
  zend_string *varname;
45779
2.45k
  zval *value;
45780
2.45k
  zval *variable_ptr;
45781
2.45k
  uintptr_t idx;
45782
2.45k
  zend_reference *ref;
45783
45784
2.49k
  ZEND_VM_REPEATABLE_OPCODE
45785
45786
2.49k
  varname = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45787
45788
  /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45789
2.49k
  idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
45790
2.49k
  if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
45791
1.86k
    Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
45792
45793
1.86k
    if (EXPECTED(p->key == varname) ||
45794
1.86k
        (EXPECTED(p->h == ZSTR_H(varname)) &&
45795
0
         EXPECTED(p->key != NULL) &&
45796
1.86k
         EXPECTED(zend_string_equal_content(p->key, varname)))) {
45797
45798
1.86k
      value = (zval*)p; /* value = &p->val; */
45799
1.86k
      goto check_indirect;
45800
1.86k
    }
45801
1.86k
  }
45802
45803
634
  value = zend_hash_find_known_hash(&EG(symbol_table), varname);
45804
634
  if (UNEXPECTED(value == NULL)) {
45805
139
    value = zend_hash_add_new(&EG(symbol_table), varname, &EG(uninitialized_zval));
45806
139
    idx = (char*)value - (char*)EG(symbol_table).arData;
45807
    /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45808
139
    CACHE_PTR(opline->extended_value, (void*)(idx + 1));
45809
495
  } else {
45810
495
    idx = (char*)value - (char*)EG(symbol_table).arData;
45811
    /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45812
495
    CACHE_PTR(opline->extended_value, (void*)(idx + 1));
45813
2.36k
check_indirect:
45814
    /* GLOBAL variable may be an INDIRECT pointer to CV */
45815
2.36k
    if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
45816
1.51k
      value = Z_INDIRECT_P(value);
45817
1.51k
      if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
45818
72
        ZVAL_NULL(value);
45819
72
      }
45820
1.51k
    }
45821
2.36k
  }
45822
45823
2.49k
  if (UNEXPECTED(!Z_ISREF_P(value))) {
45824
529
    ZVAL_MAKE_REF_EX(value, 2);
45825
529
    ref = Z_REF_P(value);
45826
1.97k
  } else {
45827
1.97k
    ref = Z_REF_P(value);
45828
1.97k
    GC_ADDREF(ref);
45829
1.97k
  }
45830
45831
2.49k
  variable_ptr = EX_VAR(opline->op1.var);
45832
45833
2.49k
  if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
45834
30
    zend_refcounted *garbage = Z_COUNTED_P(variable_ptr);
45835
45836
30
    ZVAL_REF(variable_ptr, ref);
45837
30
    SAVE_OPLINE();
45838
30
    if (GC_DELREF(garbage) == 0) {
45839
0
      rc_dtor_func(garbage);
45840
0
      if (UNEXPECTED(EG(exception))) {
45841
0
        ZVAL_NULL(variable_ptr);
45842
0
        HANDLE_EXCEPTION();
45843
0
      }
45844
30
    } else {
45845
30
      gc_check_possible_root(garbage);
45846
30
    }
45847
2.46k
  } else {
45848
2.46k
    ZVAL_REF(variable_ptr, ref);
45849
2.46k
  }
45850
45851
2.49k
  ZEND_VM_REPEAT_OPCODE(ZEND_BIND_GLOBAL);
45852
0
  ZEND_VM_NEXT_OPCODE();
45853
0
}
45854
45855
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45856
11
{
45857
11
  USE_OPLINE
45858
11
  zval *op1;
45859
11
  HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
45860
11
  zval *result;
45861
45862
11
  op1 = EX_VAR(opline->op1.var);
45863
11
  if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45864
11
    result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CV == IS_CONST);
45865
11
    if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45866
0
      zval_ptr_dtor_str(op1);
45867
0
    }
45868
11
    ZEND_VM_SMART_BRANCH(result, 0);
45869
11
  }
45870
45871
0
  if (opline->extended_value) {
45872
0
    if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45873
0
      result = zend_hash_index_find(ht, Z_LVAL_P(op1));
45874
0
      ZEND_VM_SMART_BRANCH(result, 0);
45875
0
    }
45876
0
    SAVE_OPLINE();
45877
0
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
45878
0
      op1 = Z_REFVAL_P(op1);
45879
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45880
0
        result = zend_hash_find(ht, Z_STR_P(op1));
45881
45882
0
        ZEND_VM_SMART_BRANCH(result, 0);
45883
0
      } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45884
0
        result = zend_hash_index_find(ht, Z_LVAL_P(op1));
45885
45886
0
        ZEND_VM_SMART_BRANCH(result, 0);
45887
0
      }
45888
0
    } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
45889
0
      ZVAL_UNDEFINED_OP1();
45890
0
    }
45891
0
  } else if (Z_TYPE_P(op1) <= IS_FALSE) {
45892
0
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
45893
0
      SAVE_OPLINE();
45894
0
      ZVAL_UNDEFINED_OP1();
45895
0
      if (UNEXPECTED(EG(exception) != NULL)) {
45896
0
        HANDLE_EXCEPTION();
45897
0
      }
45898
0
    }
45899
0
    result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
45900
0
    ZEND_VM_SMART_BRANCH(result, 0);
45901
0
  } else {
45902
0
    zend_string *key;
45903
0
    zval key_tmp;
45904
45905
0
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
45906
0
      op1 = Z_REFVAL_P(op1);
45907
0
      if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45908
0
        result = zend_hash_find(ht, Z_STR_P(op1));
45909
45910
0
        ZEND_VM_SMART_BRANCH(result, 0);
45911
0
      }
45912
0
    }
45913
45914
0
    SAVE_OPLINE();
45915
0
    ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
45916
0
      ZVAL_STR(&key_tmp, key);
45917
0
      if (zend_compare(op1, &key_tmp) == 0) {
45918
45919
0
        ZEND_VM_SMART_BRANCH(1, 1);
45920
0
      }
45921
0
    } ZEND_HASH_FOREACH_END();
45922
0
  }
45923
45924
0
  ZEND_VM_SMART_BRANCH(0, 1);
45925
0
}
45926
45927
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45928
1.36k
{
45929
  /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
45930
  /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
45931
  /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
45932
1.36k
  USE_OPLINE
45933
1.36k
  zval *op1, *op2;
45934
1.36k
  bool result;
45935
45936
1.36k
  op1 = EX_VAR(opline->op1.var);
45937
1.36k
  op2 = RT_CONSTANT(opline, opline->op2);
45938
1.36k
  result = fast_is_identical_function(op1, op2);
45939
  /* Free is a no-op for const/cv */
45940
1.36k
  ZEND_VM_SMART_BRANCH(result, 0);
45941
1.36k
}
45942
45943
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45944
79
{
45945
79
  USE_OPLINE
45946
79
  zval *op1, *op2;
45947
79
  bool result;
45948
45949
79
  op1 = EX_VAR(opline->op1.var);
45950
79
  op2 = RT_CONSTANT(opline, opline->op2);
45951
79
  result = fast_is_identical_function(op1, op2);
45952
  /* Free is a no-op for const/cv */
45953
79
  ZEND_VM_SMART_BRANCH(!result, 0);
45954
79
}
45955
45956
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45957
4.83k
{
45958
4.83k
  USE_OPLINE
45959
4.83k
  zval *container, *dim, *value;
45960
4.83k
  zend_long offset;
45961
4.83k
  HashTable *ht;
45962
45963
4.83k
  container = EX_VAR(opline->op1.var);
45964
4.83k
  dim = RT_CONSTANT(opline, opline->op2);
45965
4.83k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45966
2.21k
fetch_dim_r_index_array:
45967
2.21k
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
45968
2.18k
      offset = Z_LVAL_P(dim);
45969
2.18k
    } else {
45970
30
      SAVE_OPLINE();
45971
30
      zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
45972
45973
30
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45974
30
    }
45975
2.18k
    ht = Z_ARRVAL_P(container);
45976
2.18k
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
45977
2.06k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
45978
2.06k
    if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45979
0
      SAVE_OPLINE();
45980
45981
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45982
2.06k
    } else {
45983
2.06k
      ZEND_VM_NEXT_OPCODE();
45984
2.06k
    }
45985
2.65k
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
45986
48
    container = Z_REFVAL_P(container);
45987
48
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45988
34
      goto fetch_dim_r_index_array;
45989
34
    } else {
45990
14
      goto fetch_dim_r_index_slow;
45991
14
    }
45992
2.60k
  } else {
45993
2.62k
fetch_dim_r_index_slow:
45994
2.62k
    SAVE_OPLINE();
45995
2.62k
    if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45996
66
      dim++;
45997
66
    }
45998
2.62k
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45999
46000
2.62k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46001
2.62k
  }
46002
46003
120
fetch_dim_r_index_undef:
46004
120
  ZVAL_NULL(EX_VAR(opline->result.var));
46005
120
  SAVE_OPLINE();
46006
120
  zend_undefined_offset(offset);
46007
46008
120
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46009
120
}
46010
46011
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46012
3.36k
{
46013
3.36k
  USE_OPLINE
46014
3.36k
  zval *container, *dim, *value;
46015
3.36k
  zend_long offset;
46016
3.36k
  HashTable *ht;
46017
46018
3.36k
  container = EX_VAR(opline->op1.var);
46019
3.36k
  dim = EX_VAR(opline->op2.var);
46020
3.36k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46021
2.53k
fetch_dim_r_index_array:
46022
2.53k
    if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
46023
2.44k
      offset = Z_LVAL_P(dim);
46024
2.44k
    } else {
46025
90
      SAVE_OPLINE();
46026
90
      zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
46027
46028
90
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46029
90
    }
46030
2.44k
    ht = Z_ARRVAL_P(container);
46031
2.44k
    ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
46032
2.12k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46033
2.12k
    if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46034
0
      SAVE_OPLINE();
46035
46036
0
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46037
2.12k
    } else {
46038
2.12k
      ZEND_VM_NEXT_OPCODE();
46039
2.12k
    }
46040
2.12k
  } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
46041
0
    container = Z_REFVAL_P(container);
46042
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46043
0
      goto fetch_dim_r_index_array;
46044
0
    } else {
46045
0
      goto fetch_dim_r_index_slow;
46046
0
    }
46047
830
  } else {
46048
830
fetch_dim_r_index_slow:
46049
830
    SAVE_OPLINE();
46050
830
    if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46051
0
      dim++;
46052
0
    }
46053
830
    zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46054
46055
830
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46056
830
  }
46057
46058
316
fetch_dim_r_index_undef:
46059
316
  ZVAL_NULL(EX_VAR(opline->result.var));
46060
316
  SAVE_OPLINE();
46061
316
  zend_undefined_offset(offset);
46062
46063
316
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46064
316
}
46065
46066
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46067
487
{
46068
487
  USE_OPLINE
46069
487
  zval *op1, *op2;
46070
46071
487
  SAVE_OPLINE();
46072
487
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46073
487
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46074
487
  div_function(EX_VAR(opline->result.var), op1, op2);
46075
46076
487
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46077
487
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46078
487
}
46079
46080
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46081
0
{
46082
0
  USE_OPLINE
46083
0
  zval *op1, *op2;
46084
46085
0
  SAVE_OPLINE();
46086
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46087
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46088
0
  pow_function(EX_VAR(opline->result.var), op1, op2);
46089
46090
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46091
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46092
0
}
46093
46094
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46095
284k
{
46096
284k
  USE_OPLINE
46097
284k
  zval *op1, *op2;
46098
46099
284k
  op1 = EX_VAR(opline->op1.var);
46100
284k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46101
46102
284k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
46103
284k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
46104
259k
    zend_string *op1_str = Z_STR_P(op1);
46105
259k
    zend_string *op2_str = Z_STR_P(op2);
46106
259k
    zend_string *str;
46107
259k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
46108
46109
259k
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
46110
605
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
46111
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
46112
605
      } else {
46113
605
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
46114
605
      }
46115
605
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46116
0
        zend_string_release_ex(op1_str, 0);
46117
0
      }
46118
259k
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
46119
230
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
46120
230
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
46121
230
      } else {
46122
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
46123
0
      }
46124
230
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46125
230
        zend_string_release_ex(op2_str, 0);
46126
230
      }
46127
259k
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
46128
259k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
46129
0
      size_t len = ZSTR_LEN(op1_str);
46130
46131
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
46132
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
46133
0
      }
46134
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
46135
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
46136
0
      GC_ADD_FLAGS(str, flags);
46137
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
46138
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46139
0
        zend_string_release_ex(op2_str, 0);
46140
0
      }
46141
259k
    } else {
46142
259k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
46143
259k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
46144
259k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
46145
259k
      GC_ADD_FLAGS(str, flags);
46146
259k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
46147
259k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46148
0
        zend_string_release_ex(op1_str, 0);
46149
0
      }
46150
259k
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46151
259k
        zend_string_release_ex(op2_str, 0);
46152
259k
      }
46153
259k
    }
46154
259k
    ZEND_VM_NEXT_OPCODE();
46155
259k
  } else {
46156
24.1k
    SAVE_OPLINE();
46157
46158
24.1k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
46159
16.7k
      op1 = ZVAL_UNDEFINED_OP1();
46160
16.7k
    }
46161
24.1k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
46162
0
      op2 = ZVAL_UNDEFINED_OP2();
46163
0
    }
46164
24.1k
    concat_function(EX_VAR(opline->result.var), op1, op2);
46165
46166
24.1k
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46167
24.1k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46168
24.1k
  }
46169
284k
}
46170
46171
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46172
5.82k
{
46173
5.82k
  USE_OPLINE
46174
5.82k
  zval *op1, *op2;
46175
5.82k
  double d1, d2;
46176
46177
5.82k
  op1 = EX_VAR(opline->op1.var);
46178
5.82k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46179
5.82k
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46180
    /* pass */
46181
5.82k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46182
3.32k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46183
1.92k
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46184
109
is_equal_true:
46185
109
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
46186
1.83k
      } else {
46187
2.45k
is_equal_false:
46188
2.45k
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
46189
2.45k
      }
46190
1.92k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46191
0
      d1 = (double)Z_LVAL_P(op1);
46192
0
      d2 = Z_DVAL_P(op2);
46193
0
      goto is_equal_double;
46194
0
    }
46195
3.32k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46196
658
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46197
6
      d1 = Z_DVAL_P(op1);
46198
6
      d2 = Z_DVAL_P(op2);
46199
536
is_equal_double:
46200
536
      if (d1 == d2) {
46201
6
        goto is_equal_true;
46202
530
      } else {
46203
530
        goto is_equal_false;
46204
530
      }
46205
652
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46206
530
      d1 = Z_DVAL_P(op1);
46207
530
      d2 = (double)Z_LVAL_P(op2);
46208
530
      goto is_equal_double;
46209
530
    }
46210
1.84k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46211
725
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46212
112
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46213
112
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46214
0
        zval_ptr_dtor_str(op1);
46215
0
      }
46216
112
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46217
112
        zval_ptr_dtor_str(op2);
46218
112
      }
46219
112
      if (result) {
46220
13
        goto is_equal_true;
46221
99
      } else {
46222
99
        goto is_equal_false;
46223
99
      }
46224
112
    }
46225
725
  }
46226
5.82k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46227
5.82k
}
46228
46229
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46230
252
{
46231
252
  USE_OPLINE
46232
252
  zval *op1, *op2;
46233
252
  double d1, d2;
46234
46235
252
  op1 = EX_VAR(opline->op1.var);
46236
252
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46237
252
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46238
    /* pass */
46239
252
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46240
125
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46241
120
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46242
16
is_equal_true:
46243
16
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
46244
108
      } else {
46245
114
is_equal_false:
46246
114
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
46247
114
      }
46248
120
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46249
0
      d1 = (double)Z_LVAL_P(op1);
46250
0
      d2 = Z_DVAL_P(op2);
46251
0
      goto is_equal_double;
46252
0
    }
46253
127
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46254
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46255
0
      d1 = Z_DVAL_P(op1);
46256
0
      d2 = Z_DVAL_P(op2);
46257
0
is_equal_double:
46258
0
      if (d1 == d2) {
46259
0
        goto is_equal_true;
46260
0
      } else {
46261
0
        goto is_equal_false;
46262
0
      }
46263
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46264
0
      d1 = Z_DVAL_P(op1);
46265
0
      d2 = (double)Z_LVAL_P(op2);
46266
0
      goto is_equal_double;
46267
0
    }
46268
127
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46269
29
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46270
10
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46271
10
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46272
0
        zval_ptr_dtor_str(op1);
46273
0
      }
46274
10
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46275
10
        zval_ptr_dtor_str(op2);
46276
10
      }
46277
10
      if (result) {
46278
4
        goto is_equal_true;
46279
6
      } else {
46280
6
        goto is_equal_false;
46281
6
      }
46282
10
    }
46283
29
  }
46284
252
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46285
252
}
46286
46287
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46288
184
{
46289
184
  USE_OPLINE
46290
184
  zval *op1, *op2;
46291
184
  double d1, d2;
46292
46293
184
  op1 = EX_VAR(opline->op1.var);
46294
184
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46295
184
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46296
    /* pass */
46297
184
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46298
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46299
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46300
0
is_equal_true:
46301
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
46302
0
      } else {
46303
0
is_equal_false:
46304
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
46305
0
      }
46306
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46307
0
      d1 = (double)Z_LVAL_P(op1);
46308
0
      d2 = Z_DVAL_P(op2);
46309
0
      goto is_equal_double;
46310
0
    }
46311
184
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46312
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46313
0
      d1 = Z_DVAL_P(op1);
46314
0
      d2 = Z_DVAL_P(op2);
46315
0
is_equal_double:
46316
0
      if (d1 == d2) {
46317
0
        goto is_equal_true;
46318
0
      } else {
46319
0
        goto is_equal_false;
46320
0
      }
46321
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46322
0
      d1 = Z_DVAL_P(op1);
46323
0
      d2 = (double)Z_LVAL_P(op2);
46324
0
      goto is_equal_double;
46325
0
    }
46326
184
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46327
168
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46328
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46329
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46330
0
        zval_ptr_dtor_str(op1);
46331
0
      }
46332
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46333
0
        zval_ptr_dtor_str(op2);
46334
0
      }
46335
0
      if (result) {
46336
0
        goto is_equal_true;
46337
0
      } else {
46338
0
        goto is_equal_false;
46339
0
      }
46340
0
    }
46341
168
  }
46342
184
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46343
184
}
46344
46345
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46346
10.4k
{
46347
10.4k
  USE_OPLINE
46348
10.4k
  zval *op1, *op2;
46349
10.4k
  double d1, d2;
46350
46351
10.4k
  op1 = EX_VAR(opline->op1.var);
46352
10.4k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46353
10.4k
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46354
    /* pass */
46355
10.4k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46356
1.30k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46357
1.11k
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46358
1.90k
is_not_equal_true:
46359
1.90k
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
46360
1.90k
      } else {
46361
219
is_not_equal_false:
46362
219
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
46363
219
      }
46364
1.11k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46365
35
      d1 = (double)Z_LVAL_P(op1);
46366
35
      d2 = Z_DVAL_P(op2);
46367
35
      goto is_not_equal_double;
46368
35
    }
46369
9.19k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46370
255
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46371
156
      d1 = Z_DVAL_P(op1);
46372
156
      d2 = Z_DVAL_P(op2);
46373
258
is_not_equal_double:
46374
258
      if (d1 != d2) {
46375
137
        goto is_not_equal_true;
46376
137
      } else {
46377
121
        goto is_not_equal_false;
46378
121
      }
46379
258
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46380
67
      d1 = Z_DVAL_P(op1);
46381
67
      d2 = (double)Z_LVAL_P(op2);
46382
67
      goto is_not_equal_double;
46383
67
    }
46384
8.93k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46385
1.09k
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46386
745
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46387
745
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46388
0
        zval_ptr_dtor_str(op1);
46389
0
      }
46390
745
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46391
745
        zval_ptr_dtor_str(op2);
46392
745
      }
46393
745
      if (!result) {
46394
673
        goto is_not_equal_true;
46395
673
      } else {
46396
72
        goto is_not_equal_false;
46397
72
      }
46398
745
    }
46399
1.09k
  }
46400
10.4k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46401
10.4k
}
46402
46403
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46404
160
{
46405
160
  USE_OPLINE
46406
160
  zval *op1, *op2;
46407
160
  double d1, d2;
46408
46409
160
  op1 = EX_VAR(opline->op1.var);
46410
160
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46411
160
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46412
    /* pass */
46413
160
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46414
78
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46415
35
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46416
28
is_not_equal_true:
46417
28
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
46418
28
      } else {
46419
14
is_not_equal_false:
46420
14
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
46421
14
      }
46422
43
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46423
0
      d1 = (double)Z_LVAL_P(op1);
46424
0
      d2 = Z_DVAL_P(op2);
46425
0
      goto is_not_equal_double;
46426
0
    }
46427
82
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46428
7
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46429
7
      d1 = Z_DVAL_P(op1);
46430
7
      d2 = Z_DVAL_P(op2);
46431
7
is_not_equal_double:
46432
7
      if (d1 != d2) {
46433
0
        goto is_not_equal_true;
46434
7
      } else {
46435
7
        goto is_not_equal_false;
46436
7
      }
46437
7
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46438
0
      d1 = Z_DVAL_P(op1);
46439
0
      d2 = (double)Z_LVAL_P(op2);
46440
0
      goto is_not_equal_double;
46441
0
    }
46442
75
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46443
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46444
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46445
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46446
0
        zval_ptr_dtor_str(op1);
46447
0
      }
46448
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46449
0
        zval_ptr_dtor_str(op2);
46450
0
      }
46451
0
      if (!result) {
46452
0
        goto is_not_equal_true;
46453
0
      } else {
46454
0
        goto is_not_equal_false;
46455
0
      }
46456
0
    }
46457
0
  }
46458
160
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46459
160
}
46460
46461
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46462
3
{
46463
3
  USE_OPLINE
46464
3
  zval *op1, *op2;
46465
3
  double d1, d2;
46466
46467
3
  op1 = EX_VAR(opline->op1.var);
46468
3
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46469
3
  if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46470
    /* pass */
46471
3
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46472
3
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46473
0
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46474
0
is_not_equal_true:
46475
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
46476
0
      } else {
46477
0
is_not_equal_false:
46478
0
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
46479
0
      }
46480
3
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46481
0
      d1 = (double)Z_LVAL_P(op1);
46482
0
      d2 = Z_DVAL_P(op2);
46483
0
      goto is_not_equal_double;
46484
0
    }
46485
3
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46486
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46487
0
      d1 = Z_DVAL_P(op1);
46488
0
      d2 = Z_DVAL_P(op2);
46489
0
is_not_equal_double:
46490
0
      if (d1 != d2) {
46491
0
        goto is_not_equal_true;
46492
0
      } else {
46493
0
        goto is_not_equal_false;
46494
0
      }
46495
0
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46496
0
      d1 = Z_DVAL_P(op1);
46497
0
      d2 = (double)Z_LVAL_P(op2);
46498
0
      goto is_not_equal_double;
46499
0
    }
46500
0
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46501
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46502
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46503
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46504
0
        zval_ptr_dtor_str(op1);
46505
0
      }
46506
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46507
0
        zval_ptr_dtor_str(op2);
46508
0
      }
46509
0
      if (!result) {
46510
0
        goto is_not_equal_true;
46511
0
      } else {
46512
0
        goto is_not_equal_false;
46513
0
      }
46514
0
    }
46515
0
  }
46516
3
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
46517
3
}
46518
46519
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46520
0
{
46521
0
  USE_OPLINE
46522
0
  zval *op1, *op2;
46523
46524
0
  SAVE_OPLINE();
46525
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46526
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46527
0
  compare_function(EX_VAR(opline->result.var), op1, op2);
46528
46529
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46530
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46531
0
}
46532
46533
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46534
0
{
46535
0
  USE_OPLINE
46536
0
  zval *op1, *op2;
46537
46538
0
  SAVE_OPLINE();
46539
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46540
0
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46541
0
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
46542
46543
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46544
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46545
0
}
46546
46547
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46548
0
{
46549
0
  USE_OPLINE
46550
0
  zval *object;
46551
0
  zval *property;
46552
0
  zval *value;
46553
0
  zval *zptr;
46554
0
  void *_cache_slot[3] = {0};
46555
0
  void **cache_slot;
46556
0
  zend_property_info *prop_info;
46557
0
  zend_object *zobj;
46558
0
  zend_string *name, *tmp_name;
46559
46560
0
  SAVE_OPLINE();
46561
0
  object = EX_VAR(opline->op1.var);
46562
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46563
46564
0
  do {
46565
0
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
46566
46567
0
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46568
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46569
0
        object = Z_REFVAL_P(object);
46570
0
        goto assign_op_object;
46571
0
      }
46572
0
      if (IS_CV == IS_CV
46573
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46574
0
        ZVAL_UNDEFINED_OP1();
46575
0
      }
46576
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46577
0
      break;
46578
0
    }
46579
46580
0
assign_op_object:
46581
    /* here we are sure we are dealing with an object */
46582
0
    zobj = Z_OBJ_P(object);
46583
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46584
0
      name = Z_STR_P(property);
46585
0
    } else {
46586
0
      name = zval_try_get_tmp_string(property, &tmp_name);
46587
0
      if (UNEXPECTED(!name)) {
46588
0
        UNDEF_RESULT();
46589
0
        break;
46590
0
      }
46591
0
    }
46592
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
46593
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46594
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46595
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46596
0
          ZVAL_NULL(EX_VAR(opline->result.var));
46597
0
        }
46598
0
      } else {
46599
0
        zend_reference *ref;
46600
46601
0
        do {
46602
0
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
46603
0
            ref = Z_REF_P(zptr);
46604
0
            zptr = Z_REFVAL_P(zptr);
46605
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46606
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46607
0
              break;
46608
0
            }
46609
0
          }
46610
46611
0
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
46612
0
          if (prop_info) {
46613
            /* special case for typed properties */
46614
0
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
46615
0
          } else {
46616
0
            zend_binary_op(zptr, zptr, value OPLINE_CC);
46617
0
          }
46618
0
        } while (0);
46619
46620
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46621
0
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
46622
0
        }
46623
0
      }
46624
0
    } else {
46625
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
46626
0
    }
46627
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46628
0
      zend_tmp_string_release(tmp_name);
46629
0
    }
46630
0
  } while (0);
46631
46632
0
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46633
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46634
46635
  /* assign_obj has two opcodes! */
46636
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
46637
0
}
46638
46639
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
46640
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46641
649
{
46642
649
  USE_OPLINE
46643
649
  zval *var_ptr;
46644
649
  zval *value, *container, *dim;
46645
649
  HashTable *ht;
46646
46647
649
  SAVE_OPLINE();
46648
649
  container = EX_VAR(opline->op1.var);
46649
46650
649
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46651
484
assign_dim_op_array:
46652
484
    SEPARATE_ARRAY(container);
46653
484
    ht = Z_ARRVAL_P(container);
46654
644
assign_dim_op_new_array:
46655
644
    dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46656
644
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46657
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
46658
0
      if (UNEXPECTED(!var_ptr)) {
46659
0
        zend_cannot_add_element();
46660
0
        goto assign_dim_op_ret_null;
46661
0
      }
46662
644
    } else {
46663
644
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46664
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
46665
644
      } else {
46666
644
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
46667
644
      }
46668
644
      if (UNEXPECTED(!var_ptr)) {
46669
5
        goto assign_dim_op_ret_null;
46670
5
      }
46671
644
    }
46672
46673
639
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
46674
46675
639
    do {
46676
639
      if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
46677
0
        zend_reference *ref = Z_REF_P(var_ptr);
46678
0
        var_ptr = Z_REFVAL_P(var_ptr);
46679
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46680
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46681
0
          break;
46682
0
        }
46683
0
      }
46684
639
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
46685
639
    } while (0);
46686
46687
639
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46688
310
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
46689
310
    }
46690
639
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46691
639
  } else {
46692
165
    if (EXPECTED(Z_ISREF_P(container))) {
46693
0
      container = Z_REFVAL_P(container);
46694
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46695
0
        goto assign_dim_op_array;
46696
0
      }
46697
0
    }
46698
46699
165
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
46700
5
      zend_object *obj = Z_OBJ_P(container);
46701
46702
5
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46703
5
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46704
0
        dim++;
46705
0
      }
46706
5
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
46707
160
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
46708
160
      uint8_t old_type;
46709
46710
160
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
46711
160
        ZVAL_UNDEFINED_OP1();
46712
160
      }
46713
160
      ht = zend_new_array(8);
46714
160
      old_type = Z_TYPE_P(container);
46715
160
      ZVAL_ARR(container, ht);
46716
160
      if (UNEXPECTED(old_type == IS_FALSE)) {
46717
0
        GC_ADDREF(ht);
46718
0
        zend_false_to_array_deprecated();
46719
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46720
0
          zend_array_destroy(ht);
46721
0
          goto assign_dim_op_ret_null;
46722
0
        }
46723
0
      }
46724
160
      goto assign_dim_op_new_array;
46725
160
    } else {
46726
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46727
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46728
5
assign_dim_op_ret_null:
46729
5
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46730
5
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46731
5
        ZVAL_NULL(EX_VAR(opline->result.var));
46732
5
      }
46733
5
    }
46734
165
  }
46735
46736
649
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46737
46738
649
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
46739
649
}
46740
46741
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46742
2.14M
{
46743
2.14M
  USE_OPLINE
46744
2.14M
  zval *var_ptr;
46745
2.14M
  zval *value;
46746
46747
2.14M
  SAVE_OPLINE();
46748
2.14M
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46749
2.14M
  var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
46750
46751
2.14M
  do {
46752
2.14M
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
46753
6.66k
      zend_reference *ref = Z_REF_P(var_ptr);
46754
6.66k
      var_ptr = Z_REFVAL_P(var_ptr);
46755
6.66k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46756
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46757
0
        break;
46758
0
      }
46759
6.66k
    }
46760
2.14M
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
46761
2.14M
  } while (0);
46762
46763
2.14M
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46764
1.56M
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
46765
1.56M
  }
46766
46767
2.14M
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46768
46769
2.14M
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46770
2.14M
}
46771
46772
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46773
0
{
46774
0
  USE_OPLINE
46775
0
  zval *object;
46776
0
  zval *property;
46777
0
  zval *zptr;
46778
0
  void *_cache_slot[3] = {0};
46779
0
  void **cache_slot;
46780
0
  zend_property_info *prop_info;
46781
0
  zend_object *zobj;
46782
0
  zend_string *name, *tmp_name;
46783
46784
0
  SAVE_OPLINE();
46785
0
  object = EX_VAR(opline->op1.var);
46786
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46787
46788
0
  do {
46789
0
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46790
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46791
0
        object = Z_REFVAL_P(object);
46792
0
        goto pre_incdec_object;
46793
0
      }
46794
0
      if (IS_CV == IS_CV
46795
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46796
0
        ZVAL_UNDEFINED_OP1();
46797
0
      }
46798
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46799
0
      break;
46800
0
    }
46801
46802
0
pre_incdec_object:
46803
    /* here we are sure we are dealing with an object */
46804
0
    zobj = Z_OBJ_P(object);
46805
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46806
0
      name = Z_STR_P(property);
46807
0
    } else {
46808
0
      name = zval_try_get_tmp_string(property, &tmp_name);
46809
0
      if (UNEXPECTED(!name)) {
46810
0
        UNDEF_RESULT();
46811
0
        break;
46812
0
      }
46813
0
    }
46814
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
46815
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46816
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46817
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46818
0
          ZVAL_NULL(EX_VAR(opline->result.var));
46819
0
        }
46820
0
      } else {
46821
0
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
46822
0
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
46823
0
      }
46824
0
    } else {
46825
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
46826
0
    }
46827
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46828
0
      zend_tmp_string_release(tmp_name);
46829
0
    }
46830
0
  } while (0);
46831
46832
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46833
46834
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46835
0
}
46836
46837
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46838
0
{
46839
0
  USE_OPLINE
46840
0
  zval *object;
46841
0
  zval *property;
46842
0
  zval *zptr;
46843
0
  void *_cache_slot[3] = {0};
46844
0
  void **cache_slot;
46845
0
  zend_property_info *prop_info;
46846
0
  zend_object *zobj;
46847
0
  zend_string *name, *tmp_name;
46848
46849
0
  SAVE_OPLINE();
46850
0
  object = EX_VAR(opline->op1.var);
46851
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46852
46853
0
  do {
46854
0
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46855
0
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46856
0
        object = Z_REFVAL_P(object);
46857
0
        goto post_incdec_object;
46858
0
      }
46859
0
      if (IS_CV == IS_CV
46860
0
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46861
0
        ZVAL_UNDEFINED_OP1();
46862
0
      }
46863
0
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46864
0
      break;
46865
0
    }
46866
46867
0
post_incdec_object:
46868
    /* here we are sure we are dealing with an object */
46869
0
    zobj = Z_OBJ_P(object);
46870
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46871
0
      name = Z_STR_P(property);
46872
0
    } else {
46873
0
      name = zval_try_get_tmp_string(property, &tmp_name);
46874
0
      if (UNEXPECTED(!name)) {
46875
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
46876
0
        break;
46877
0
      }
46878
0
    }
46879
0
    cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
46880
0
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46881
0
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46882
0
        ZVAL_NULL(EX_VAR(opline->result.var));
46883
0
      } else {
46884
0
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
46885
0
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
46886
0
      }
46887
0
    } else {
46888
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
46889
0
    }
46890
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46891
0
      zend_tmp_string_release(tmp_name);
46892
0
    }
46893
0
  } while (0);
46894
46895
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46896
46897
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46898
0
}
46899
46900
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46901
897
{
46902
897
  USE_OPLINE
46903
897
  zval *container, *dim, *value;
46904
46905
897
  SAVE_OPLINE();
46906
897
  container = EX_VAR(opline->op1.var);
46907
897
  dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46908
897
  if (IS_CV != IS_CONST) {
46909
897
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46910
765
fetch_dim_r_array:
46911
765
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
46912
765
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46913
765
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
46914
0
      container = Z_REFVAL_P(container);
46915
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46916
0
        goto fetch_dim_r_array;
46917
0
      } else {
46918
0
        goto fetch_dim_r_slow;
46919
0
      }
46920
132
    } else {
46921
132
fetch_dim_r_slow:
46922
132
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46923
0
        dim++;
46924
0
      }
46925
132
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46926
132
    }
46927
897
  } else {
46928
0
    zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
46929
0
  }
46930
897
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46931
46932
897
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46933
897
}
46934
46935
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46936
220
{
46937
220
  USE_OPLINE
46938
220
  zval *container;
46939
46940
220
  SAVE_OPLINE();
46941
220
  container = EX_VAR(opline->op1.var);
46942
220
  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);
46943
220
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46944
220
  if (IS_CV == IS_VAR) {
46945
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46946
0
  }
46947
220
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46948
220
}
46949
46950
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46951
368
{
46952
368
  USE_OPLINE
46953
368
  zval *container;
46954
46955
368
  SAVE_OPLINE();
46956
368
  container = EX_VAR(opline->op1.var);
46957
368
  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);
46958
368
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46959
368
  if (IS_CV == IS_VAR) {
46960
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46961
0
  }
46962
368
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46963
368
}
46964
46965
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46966
149
{
46967
149
  USE_OPLINE
46968
149
  zval *container;
46969
46970
149
  SAVE_OPLINE();
46971
149
  container = EX_VAR(opline->op1.var);
46972
149
  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);
46973
149
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46974
46975
149
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46976
149
}
46977
46978
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46979
0
{
46980
#if 0
46981
  USE_OPLINE
46982
#endif
46983
46984
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
46985
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
46986
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46987
0
    }
46988
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46989
0
  } else {
46990
0
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46991
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46992
0
    }
46993
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46994
0
  }
46995
0
}
46996
46997
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46998
0
{
46999
0
  USE_OPLINE
47000
0
  zval *container;
47001
47002
0
  SAVE_OPLINE();
47003
0
  container = EX_VAR(opline->op1.var);
47004
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);
47005
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47006
0
  if (IS_CV == IS_VAR) {
47007
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47008
0
  }
47009
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47010
0
}
47011
47012
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47013
72
{
47014
72
  USE_OPLINE
47015
72
  zval *container;
47016
72
  void **cache_slot = NULL;
47017
47018
72
  SAVE_OPLINE();
47019
72
  container = EX_VAR(opline->op1.var);
47020
47021
72
  if (IS_CV == IS_CONST ||
47022
72
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
47023
15
    do {
47024
15
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
47025
12
        container = Z_REFVAL_P(container);
47026
12
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
47027
0
          break;
47028
0
        }
47029
12
      }
47030
15
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
47031
3
        ZVAL_UNDEFINED_OP1();
47032
3
      }
47033
15
      zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47034
15
      ZVAL_NULL(EX_VAR(opline->result.var));
47035
15
      goto fetch_obj_r_finish;
47036
15
    } while (0);
47037
15
  }
47038
47039
  /* here we are sure we are dealing with an object */
47040
57
  do {
47041
57
    zend_object *zobj = Z_OBJ_P(container);
47042
57
    zend_string *name, *tmp_name;
47043
57
    zval *retval;
47044
47045
57
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47046
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
47047
47048
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
47049
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47050
47051
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47052
0
fetch_obj_r_simple:
47053
0
          retval = OBJ_PROP(zobj, prop_offset);
47054
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
47055
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47056
0
              goto fetch_obj_r_copy;
47057
0
            } else {
47058
0
fetch_obj_r_fast_copy:
47059
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47060
0
              ZEND_VM_NEXT_OPCODE();
47061
0
            }
47062
0
          }
47063
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
47064
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47065
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
47066
0
            prop_offset = prop_info->offset;
47067
0
            goto fetch_obj_r_simple;
47068
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
47069
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
47070
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
47071
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
47072
47073
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
47074
0
            if (IS_CV & IS_CV) {
47075
0
              GC_ADDREF(zobj);
47076
0
            }
47077
0
            if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
47078
0
              call_info |= ZEND_CALL_RELEASE_THIS;
47079
0
            }
47080
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
47081
0
            call->prev_execute_data = execute_data;
47082
0
            call->call = NULL;
47083
0
            call->return_value = EX_VAR(opline->result.var);
47084
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
47085
47086
0
            execute_data = call;
47087
0
            EG(current_execute_data) = execute_data;
47088
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
47089
47090
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
47091
            opline = hook->op_array.opcodes;
47092
#else
47093
0
            EX(opline) = hook->op_array.opcodes;
47094
0
#endif
47095
0
            LOAD_OPLINE_EX();
47096
47097
47098
0
            ZEND_VM_ENTER_EX();
47099
0
          }
47100
          /* Fall through to read_property for hooks. */
47101
0
        } else if (EXPECTED(zobj->properties != NULL)) {
47102
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
47103
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47104
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
47105
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
47106
47107
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
47108
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
47109
47110
0
              if (EXPECTED(p->key == name) ||
47111
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
47112
0
                   EXPECTED(p->key != NULL) &&
47113
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
47114
0
                retval = &p->val;
47115
0
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47116
0
                  goto fetch_obj_r_copy;
47117
0
                } else {
47118
0
                  goto fetch_obj_r_fast_copy;
47119
0
                }
47120
0
              }
47121
0
            }
47122
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
47123
0
          }
47124
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
47125
0
          if (EXPECTED(retval)) {
47126
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
47127
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
47128
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47129
0
              goto fetch_obj_r_copy;
47130
0
            } else {
47131
0
              goto fetch_obj_r_fast_copy;
47132
0
            }
47133
0
          }
47134
0
        }
47135
0
      }
47136
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47137
57
    } else {
47138
57
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47139
57
      if (UNEXPECTED(!name)) {
47140
5
        ZVAL_UNDEF(EX_VAR(opline->result.var));
47141
5
        break;
47142
5
      }
47143
57
    }
47144
47145
52
#if ZEND_DEBUG
47146
    /* For non-standard object handlers, verify a declared property type in debug builds.
47147
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
47148
52
    zend_property_info *prop_info = NULL;
47149
52
    if (zobj->handlers->read_property != zend_std_read_property) {
47150
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
47151
0
    }
47152
52
#endif
47153
52
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
47154
52
#if ZEND_DEBUG
47155
52
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
47156
52
        && ZEND_TYPE_IS_SET(prop_info->type)) {
47157
0
      ZVAL_OPT_DEREF(retval);
47158
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
47159
0
    }
47160
52
#endif
47161
47162
52
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47163
52
      zend_tmp_string_release(tmp_name);
47164
52
    }
47165
47166
52
    if (retval != EX_VAR(opline->result.var)) {
47167
2
fetch_obj_r_copy:
47168
2
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47169
50
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
47170
0
      zend_unwrap_reference(retval);
47171
0
    }
47172
52
  } while (0);
47173
47174
72
fetch_obj_r_finish:
47175
72
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47176
47177
72
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47178
72
}
47179
47180
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47181
3
{
47182
3
  USE_OPLINE
47183
3
  zval *property, *container, *result;
47184
47185
3
  SAVE_OPLINE();
47186
47187
3
  container = EX_VAR(opline->op1.var);
47188
3
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47189
3
  result = EX_VAR(opline->result.var);
47190
3
  zend_fetch_property_address(
47191
3
    result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR),
47192
3
    (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
47193
3
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
47194
3
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47195
3
  if (IS_CV == IS_VAR) {
47196
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47197
0
  }
47198
3
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47199
3
}
47200
47201
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47202
0
{
47203
0
  USE_OPLINE
47204
0
  zval *property, *container, *result;
47205
47206
0
  SAVE_OPLINE();
47207
0
  container = EX_VAR(opline->op1.var);
47208
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47209
0
  result = EX_VAR(opline->result.var);
47210
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);
47211
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47212
0
  if (IS_CV == IS_VAR) {
47213
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47214
0
  }
47215
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47216
0
}
47217
47218
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47219
45
{
47220
45
  USE_OPLINE
47221
45
  zval *container;
47222
45
  void **cache_slot = NULL;
47223
47224
45
  SAVE_OPLINE();
47225
45
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
47226
47227
45
  if (IS_CV == IS_CONST ||
47228
45
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
47229
0
    do {
47230
0
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
47231
0
        container = Z_REFVAL_P(container);
47232
0
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
47233
0
          break;
47234
0
        }
47235
0
      }
47236
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
47237
0
        ZVAL_UNDEFINED_OP2();
47238
0
      }
47239
0
      ZVAL_NULL(EX_VAR(opline->result.var));
47240
0
      goto fetch_obj_is_finish;
47241
0
    } while (0);
47242
0
  }
47243
47244
  /* here we are sure we are dealing with an object */
47245
45
  do {
47246
45
    zend_object *zobj = Z_OBJ_P(container);
47247
45
    zend_string *name, *tmp_name;
47248
45
    zval *retval;
47249
47250
45
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47251
0
      cache_slot = CACHE_ADDR(opline->extended_value);
47252
47253
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
47254
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47255
47256
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47257
0
fetch_obj_is_simple:
47258
0
          retval = OBJ_PROP(zobj, prop_offset);
47259
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
47260
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47261
0
              goto fetch_obj_is_copy;
47262
0
            } else {
47263
0
fetch_obj_is_fast_copy:
47264
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47265
0
              ZEND_VM_NEXT_OPCODE();
47266
0
            }
47267
0
          }
47268
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
47269
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
47270
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47271
0
            prop_offset = prop_info->offset;
47272
0
            goto fetch_obj_is_simple;
47273
0
          }
47274
          /* Fall through to read_property for hooks. */
47275
0
        } else if (EXPECTED(zobj->properties != NULL)) {
47276
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
47277
0
          name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47278
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
47279
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
47280
47281
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
47282
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
47283
47284
0
              if (EXPECTED(p->key == name) ||
47285
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
47286
0
                   EXPECTED(p->key != NULL) &&
47287
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
47288
0
                retval = &p->val;
47289
0
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47290
0
                  goto fetch_obj_is_copy;
47291
0
                } else {
47292
0
                  goto fetch_obj_is_fast_copy;
47293
0
                }
47294
0
              }
47295
0
            }
47296
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
47297
0
          }
47298
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
47299
0
          if (EXPECTED(retval)) {
47300
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
47301
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
47302
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47303
0
              goto fetch_obj_is_copy;
47304
0
            } else {
47305
0
              goto fetch_obj_is_fast_copy;
47306
0
            }
47307
0
          }
47308
0
        }
47309
0
      }
47310
0
      name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47311
45
    } else {
47312
45
      name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47313
45
      if (UNEXPECTED(!name)) {
47314
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
47315
0
        break;
47316
0
      }
47317
45
    }
47318
47319
45
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
47320
47321
45
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47322
45
      zend_tmp_string_release(tmp_name);
47323
45
    }
47324
47325
45
    if (retval != EX_VAR(opline->result.var)) {
47326
45
fetch_obj_is_copy:
47327
45
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47328
45
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
47329
0
      zend_unwrap_reference(retval);
47330
0
    }
47331
45
  } while (0);
47332
47333
45
fetch_obj_is_finish:
47334
45
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47335
47336
45
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47337
45
}
47338
47339
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47340
0
{
47341
#if 0
47342
  USE_OPLINE
47343
#endif
47344
47345
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
47346
    /* Behave like FETCH_OBJ_W */
47347
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
47348
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47349
0
    }
47350
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47351
0
  } else {
47352
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47353
0
  }
47354
0
}
47355
47356
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47357
0
{
47358
0
  USE_OPLINE
47359
0
  zval *container, *property, *result;
47360
47361
0
  SAVE_OPLINE();
47362
0
  container = EX_VAR(opline->op1.var);
47363
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47364
0
  result = EX_VAR(opline->result.var);
47365
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);
47366
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47367
0
  if (IS_CV == IS_VAR) {
47368
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47369
0
  }
47370
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47371
0
}
47372
47373
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47374
69
{
47375
69
  USE_OPLINE
47376
69
  zval *object, *value, tmp;
47377
69
  zend_object *zobj;
47378
69
  zend_string *name, *tmp_name;
47379
69
  zend_refcounted *garbage = NULL;
47380
47381
69
  SAVE_OPLINE();
47382
69
  object = EX_VAR(opline->op1.var);
47383
69
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
47384
47385
69
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47386
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47387
0
      object = Z_REFVAL_P(object);
47388
0
      goto assign_object;
47389
0
    }
47390
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47391
0
    value = &EG(uninitialized_zval);
47392
0
    goto free_and_exit_assign_obj;
47393
0
  }
47394
47395
69
assign_object:
47396
69
  zobj = Z_OBJ_P(object);
47397
69
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47398
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47399
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
47400
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47401
0
      zval *property_val;
47402
0
      zend_property_info *prop_info;
47403
47404
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47405
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47406
47407
0
assign_obj_simple:
47408
0
        property_val = OBJ_PROP(zobj, prop_offset);
47409
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
47410
0
          if (prop_info != NULL) {
47411
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47412
0
            goto free_and_exit_assign_obj;
47413
0
          } else {
47414
0
fast_assign_obj:
47415
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
47416
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47417
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
47418
0
            }
47419
0
            goto exit_assign_obj;
47420
0
          }
47421
0
        }
47422
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47423
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47424
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47425
0
          zobj = zend_lazy_object_init(zobj);
47426
0
          if (!zobj) {
47427
0
            value = &EG(uninitialized_zval);
47428
0
            goto free_and_exit_assign_obj;
47429
0
          }
47430
0
        }
47431
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47432
0
          rebuild_object_properties_internal(zobj);
47433
0
        }
47434
0
        if (EXPECTED(zobj->properties != NULL)) {
47435
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47436
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47437
0
              GC_DELREF(zobj->properties);
47438
0
            }
47439
0
            zobj->properties = zend_array_dup(zobj->properties);
47440
0
          }
47441
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
47442
0
          if (property_val) {
47443
0
            goto fast_assign_obj;
47444
0
          }
47445
0
        }
47446
47447
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47448
0
          if (IS_CONST == IS_CONST) {
47449
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47450
0
              Z_ADDREF_P(value);
47451
0
            }
47452
0
          } else if (IS_CONST != IS_TMP_VAR) {
47453
0
            if (Z_ISREF_P(value)) {
47454
0
              if (IS_CONST == IS_VAR) {
47455
0
                zend_reference *ref = Z_REF_P(value);
47456
0
                if (GC_DELREF(ref) == 0) {
47457
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47458
0
                  efree_size(ref, sizeof(zend_reference));
47459
0
                  value = &tmp;
47460
0
                } else {
47461
0
                  value = Z_REFVAL_P(value);
47462
0
                  Z_TRY_ADDREF_P(value);
47463
0
                }
47464
0
              } else {
47465
0
                value = Z_REFVAL_P(value);
47466
0
                Z_TRY_ADDREF_P(value);
47467
0
              }
47468
0
            } else if (IS_CONST == IS_CV) {
47469
0
              Z_TRY_ADDREF_P(value);
47470
0
            }
47471
0
          }
47472
0
          zend_hash_add_new(zobj->properties, name, value);
47473
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47474
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
47475
0
          }
47476
0
          goto exit_assign_obj;
47477
0
        }
47478
0
      } else {
47479
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47480
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47481
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
47482
0
          prop_offset = prop_info->offset;
47483
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47484
0
            prop_info = NULL;
47485
0
          }
47486
0
          goto assign_obj_simple;
47487
0
        }
47488
        /* Fall through to write_property for hooks. */
47489
0
      }
47490
0
    }
47491
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47492
69
  } else {
47493
69
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47494
69
    if (UNEXPECTED(!name)) {
47495
47496
0
      UNDEF_RESULT();
47497
0
      goto exit_assign_obj;
47498
0
    }
47499
69
  }
47500
47501
69
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
47502
0
    ZVAL_DEREF(value);
47503
0
  }
47504
47505
69
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47506
47507
69
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47508
69
    zend_tmp_string_release(tmp_name);
47509
69
  }
47510
47511
69
free_and_exit_assign_obj:
47512
69
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47513
15
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47514
15
  }
47515
47516
69
exit_assign_obj:
47517
69
  if (garbage) {
47518
0
    GC_DTOR_NO_REF(garbage);
47519
0
  }
47520
69
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47521
47522
  /* assign_obj has two opcodes! */
47523
69
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
47524
69
}
47525
47526
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47527
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47528
0
{
47529
0
  USE_OPLINE
47530
0
  zval *object, *value, tmp;
47531
0
  zend_object *zobj;
47532
0
  zend_string *name, *tmp_name;
47533
0
  zend_refcounted *garbage = NULL;
47534
47535
0
  SAVE_OPLINE();
47536
0
  object = EX_VAR(opline->op1.var);
47537
0
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
47538
47539
0
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47540
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47541
0
      object = Z_REFVAL_P(object);
47542
0
      goto assign_object;
47543
0
    }
47544
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47545
0
    value = &EG(uninitialized_zval);
47546
0
    goto free_and_exit_assign_obj;
47547
0
  }
47548
47549
0
assign_object:
47550
0
  zobj = Z_OBJ_P(object);
47551
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47552
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47553
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
47554
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47555
0
      zval *property_val;
47556
0
      zend_property_info *prop_info;
47557
47558
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47559
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47560
47561
0
assign_obj_simple:
47562
0
        property_val = OBJ_PROP(zobj, prop_offset);
47563
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
47564
0
          if (prop_info != NULL) {
47565
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47566
0
            goto free_and_exit_assign_obj;
47567
0
          } else {
47568
0
fast_assign_obj:
47569
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
47570
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47571
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
47572
0
            }
47573
0
            goto exit_assign_obj;
47574
0
          }
47575
0
        }
47576
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47577
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47578
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47579
0
          zobj = zend_lazy_object_init(zobj);
47580
0
          if (!zobj) {
47581
0
            value = &EG(uninitialized_zval);
47582
0
            goto free_and_exit_assign_obj;
47583
0
          }
47584
0
        }
47585
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47586
0
          rebuild_object_properties_internal(zobj);
47587
0
        }
47588
0
        if (EXPECTED(zobj->properties != NULL)) {
47589
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47590
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47591
0
              GC_DELREF(zobj->properties);
47592
0
            }
47593
0
            zobj->properties = zend_array_dup(zobj->properties);
47594
0
          }
47595
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
47596
0
          if (property_val) {
47597
0
            goto fast_assign_obj;
47598
0
          }
47599
0
        }
47600
47601
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47602
0
          if (IS_TMP_VAR == IS_CONST) {
47603
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47604
0
              Z_ADDREF_P(value);
47605
0
            }
47606
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
47607
0
            if (Z_ISREF_P(value)) {
47608
0
              if (IS_TMP_VAR == IS_VAR) {
47609
0
                zend_reference *ref = Z_REF_P(value);
47610
0
                if (GC_DELREF(ref) == 0) {
47611
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47612
0
                  efree_size(ref, sizeof(zend_reference));
47613
0
                  value = &tmp;
47614
0
                } else {
47615
0
                  value = Z_REFVAL_P(value);
47616
0
                  Z_TRY_ADDREF_P(value);
47617
0
                }
47618
0
              } else {
47619
0
                value = Z_REFVAL_P(value);
47620
0
                Z_TRY_ADDREF_P(value);
47621
0
              }
47622
0
            } else if (IS_TMP_VAR == IS_CV) {
47623
0
              Z_TRY_ADDREF_P(value);
47624
0
            }
47625
0
          }
47626
0
          zend_hash_add_new(zobj->properties, name, value);
47627
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47628
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
47629
0
          }
47630
0
          goto exit_assign_obj;
47631
0
        }
47632
0
      } else {
47633
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47634
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47635
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
47636
0
          prop_offset = prop_info->offset;
47637
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47638
0
            prop_info = NULL;
47639
0
          }
47640
0
          goto assign_obj_simple;
47641
0
        }
47642
        /* Fall through to write_property for hooks. */
47643
0
      }
47644
0
    }
47645
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47646
0
  } else {
47647
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47648
0
    if (UNEXPECTED(!name)) {
47649
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47650
0
      UNDEF_RESULT();
47651
0
      goto exit_assign_obj;
47652
0
    }
47653
0
  }
47654
47655
0
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
47656
0
    ZVAL_DEREF(value);
47657
0
  }
47658
47659
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47660
47661
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47662
0
    zend_tmp_string_release(tmp_name);
47663
0
  }
47664
47665
0
free_and_exit_assign_obj:
47666
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47667
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47668
0
  }
47669
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47670
0
exit_assign_obj:
47671
0
  if (garbage) {
47672
0
    GC_DTOR_NO_REF(garbage);
47673
0
  }
47674
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47675
47676
  /* assign_obj has two opcodes! */
47677
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
47678
0
}
47679
47680
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47681
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47682
0
{
47683
0
  USE_OPLINE
47684
0
  zval *object, *value, tmp;
47685
0
  zend_object *zobj;
47686
0
  zend_string *name, *tmp_name;
47687
0
  zend_refcounted *garbage = NULL;
47688
47689
0
  SAVE_OPLINE();
47690
0
  object = EX_VAR(opline->op1.var);
47691
0
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
47692
47693
0
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47694
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47695
0
      object = Z_REFVAL_P(object);
47696
0
      goto assign_object;
47697
0
    }
47698
0
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47699
0
    value = &EG(uninitialized_zval);
47700
0
    goto free_and_exit_assign_obj;
47701
0
  }
47702
47703
0
assign_object:
47704
0
  zobj = Z_OBJ_P(object);
47705
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47706
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47707
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
47708
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47709
0
      zval *property_val;
47710
0
      zend_property_info *prop_info;
47711
47712
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47713
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47714
47715
0
assign_obj_simple:
47716
0
        property_val = OBJ_PROP(zobj, prop_offset);
47717
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
47718
0
          if (prop_info != NULL) {
47719
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47720
0
            goto free_and_exit_assign_obj;
47721
0
          } else {
47722
0
fast_assign_obj:
47723
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
47724
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47725
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
47726
0
            }
47727
0
            goto exit_assign_obj;
47728
0
          }
47729
0
        }
47730
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47731
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47732
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47733
0
          zobj = zend_lazy_object_init(zobj);
47734
0
          if (!zobj) {
47735
0
            value = &EG(uninitialized_zval);
47736
0
            goto free_and_exit_assign_obj;
47737
0
          }
47738
0
        }
47739
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47740
0
          rebuild_object_properties_internal(zobj);
47741
0
        }
47742
0
        if (EXPECTED(zobj->properties != NULL)) {
47743
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47744
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47745
0
              GC_DELREF(zobj->properties);
47746
0
            }
47747
0
            zobj->properties = zend_array_dup(zobj->properties);
47748
0
          }
47749
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
47750
0
          if (property_val) {
47751
0
            goto fast_assign_obj;
47752
0
          }
47753
0
        }
47754
47755
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47756
0
          if (IS_VAR == IS_CONST) {
47757
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47758
0
              Z_ADDREF_P(value);
47759
0
            }
47760
0
          } else if (IS_VAR != IS_TMP_VAR) {
47761
0
            if (Z_ISREF_P(value)) {
47762
0
              if (IS_VAR == IS_VAR) {
47763
0
                zend_reference *ref = Z_REF_P(value);
47764
0
                if (GC_DELREF(ref) == 0) {
47765
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47766
0
                  efree_size(ref, sizeof(zend_reference));
47767
0
                  value = &tmp;
47768
0
                } else {
47769
0
                  value = Z_REFVAL_P(value);
47770
0
                  Z_TRY_ADDREF_P(value);
47771
0
                }
47772
0
              } else {
47773
0
                value = Z_REFVAL_P(value);
47774
0
                Z_TRY_ADDREF_P(value);
47775
0
              }
47776
0
            } else if (IS_VAR == IS_CV) {
47777
0
              Z_TRY_ADDREF_P(value);
47778
0
            }
47779
0
          }
47780
0
          zend_hash_add_new(zobj->properties, name, value);
47781
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47782
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
47783
0
          }
47784
0
          goto exit_assign_obj;
47785
0
        }
47786
0
      } else {
47787
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47788
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47789
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
47790
0
          prop_offset = prop_info->offset;
47791
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47792
0
            prop_info = NULL;
47793
0
          }
47794
0
          goto assign_obj_simple;
47795
0
        }
47796
        /* Fall through to write_property for hooks. */
47797
0
      }
47798
0
    }
47799
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47800
0
  } else {
47801
0
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47802
0
    if (UNEXPECTED(!name)) {
47803
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47804
0
      UNDEF_RESULT();
47805
0
      goto exit_assign_obj;
47806
0
    }
47807
0
  }
47808
47809
0
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
47810
0
    ZVAL_DEREF(value);
47811
0
  }
47812
47813
0
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47814
47815
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47816
0
    zend_tmp_string_release(tmp_name);
47817
0
  }
47818
47819
0
free_and_exit_assign_obj:
47820
0
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47821
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47822
0
  }
47823
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47824
0
exit_assign_obj:
47825
0
  if (garbage) {
47826
0
    GC_DTOR_NO_REF(garbage);
47827
0
  }
47828
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47829
47830
  /* assign_obj has two opcodes! */
47831
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
47832
0
}
47833
47834
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47835
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47836
415
{
47837
415
  USE_OPLINE
47838
415
  zval *object, *value, tmp;
47839
415
  zend_object *zobj;
47840
415
  zend_string *name, *tmp_name;
47841
415
  zend_refcounted *garbage = NULL;
47842
47843
415
  SAVE_OPLINE();
47844
415
  object = EX_VAR(opline->op1.var);
47845
415
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
47846
47847
415
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47848
400
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47849
398
      object = Z_REFVAL_P(object);
47850
398
      goto assign_object;
47851
398
    }
47852
2
    zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47853
2
    value = &EG(uninitialized_zval);
47854
2
    goto free_and_exit_assign_obj;
47855
400
  }
47856
47857
413
assign_object:
47858
413
  zobj = Z_OBJ_P(object);
47859
413
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47860
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47861
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
47862
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47863
0
      zval *property_val;
47864
0
      zend_property_info *prop_info;
47865
47866
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47867
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47868
47869
0
assign_obj_simple:
47870
0
        property_val = OBJ_PROP(zobj, prop_offset);
47871
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
47872
0
          if (prop_info != NULL) {
47873
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47874
0
            goto free_and_exit_assign_obj;
47875
0
          } else {
47876
0
fast_assign_obj:
47877
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
47878
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47879
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
47880
0
            }
47881
0
            goto exit_assign_obj;
47882
0
          }
47883
0
        }
47884
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47885
0
        name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47886
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47887
0
          zobj = zend_lazy_object_init(zobj);
47888
0
          if (!zobj) {
47889
0
            value = &EG(uninitialized_zval);
47890
0
            goto free_and_exit_assign_obj;
47891
0
          }
47892
0
        }
47893
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47894
0
          rebuild_object_properties_internal(zobj);
47895
0
        }
47896
0
        if (EXPECTED(zobj->properties != NULL)) {
47897
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47898
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47899
0
              GC_DELREF(zobj->properties);
47900
0
            }
47901
0
            zobj->properties = zend_array_dup(zobj->properties);
47902
0
          }
47903
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
47904
0
          if (property_val) {
47905
0
            goto fast_assign_obj;
47906
0
          }
47907
0
        }
47908
47909
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47910
0
          if (IS_CV == IS_CONST) {
47911
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47912
0
              Z_ADDREF_P(value);
47913
0
            }
47914
0
          } else if (IS_CV != IS_TMP_VAR) {
47915
0
            if (Z_ISREF_P(value)) {
47916
0
              if (IS_CV == IS_VAR) {
47917
0
                zend_reference *ref = Z_REF_P(value);
47918
0
                if (GC_DELREF(ref) == 0) {
47919
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47920
0
                  efree_size(ref, sizeof(zend_reference));
47921
0
                  value = &tmp;
47922
0
                } else {
47923
0
                  value = Z_REFVAL_P(value);
47924
0
                  Z_TRY_ADDREF_P(value);
47925
0
                }
47926
0
              } else {
47927
0
                value = Z_REFVAL_P(value);
47928
0
                Z_TRY_ADDREF_P(value);
47929
0
              }
47930
0
            } else if (IS_CV == IS_CV) {
47931
0
              Z_TRY_ADDREF_P(value);
47932
0
            }
47933
0
          }
47934
0
          zend_hash_add_new(zobj->properties, name, value);
47935
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47936
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
47937
0
          }
47938
0
          goto exit_assign_obj;
47939
0
        }
47940
0
      } else {
47941
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47942
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47943
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
47944
0
          prop_offset = prop_info->offset;
47945
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47946
0
            prop_info = NULL;
47947
0
          }
47948
0
          goto assign_obj_simple;
47949
0
        }
47950
        /* Fall through to write_property for hooks. */
47951
0
      }
47952
0
    }
47953
0
    name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47954
413
  } else {
47955
413
    name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47956
413
    if (UNEXPECTED(!name)) {
47957
47958
0
      UNDEF_RESULT();
47959
0
      goto exit_assign_obj;
47960
0
    }
47961
413
  }
47962
47963
413
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
47964
413
    ZVAL_DEREF(value);
47965
413
  }
47966
47967
413
  value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47968
47969
413
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47970
413
    zend_tmp_string_release(tmp_name);
47971
413
  }
47972
47973
415
free_and_exit_assign_obj:
47974
415
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47975
15
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47976
15
  }
47977
47978
415
exit_assign_obj:
47979
415
  if (garbage) {
47980
0
    GC_DTOR_NO_REF(garbage);
47981
0
  }
47982
415
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47983
47984
  /* assign_obj has two opcodes! */
47985
415
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
47986
415
}
47987
47988
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47989
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47990
282
{
47991
282
  USE_OPLINE
47992
282
  zval *object_ptr, *orig_object_ptr;
47993
282
  zval *value;
47994
282
  zval *variable_ptr;
47995
282
  zval *dim;
47996
282
  zend_refcounted *garbage = NULL;
47997
47998
282
  SAVE_OPLINE();
47999
282
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48000
48001
282
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48002
180
try_assign_dim_array:
48003
180
    SEPARATE_ARRAY(object_ptr);
48004
180
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48005
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
48006
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48007
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
48008
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48009
0
          GC_ADDREF(ht);
48010
0
        }
48011
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48012
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48013
0
          zend_array_destroy(ht);
48014
0
          goto assign_dim_error;
48015
0
        }
48016
0
      }
48017
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
48018
0
        ZVAL_DEREF(value);
48019
0
      }
48020
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48021
0
      if (UNEXPECTED(value == NULL)) {
48022
0
        zend_cannot_add_element();
48023
0
        goto assign_dim_error;
48024
0
      } else if (IS_CONST == IS_CV) {
48025
0
        if (Z_REFCOUNTED_P(value)) {
48026
0
          Z_ADDREF_P(value);
48027
0
        }
48028
0
      } else if (IS_CONST == IS_VAR) {
48029
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
48030
0
        if (Z_ISREF_P(free_op_data)) {
48031
0
          if (Z_REFCOUNTED_P(value)) {
48032
0
            Z_ADDREF_P(value);
48033
0
          }
48034
0
          zval_ptr_dtor_nogc(free_op_data);
48035
0
        }
48036
0
      } else if (IS_CONST == IS_CONST) {
48037
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48038
0
          Z_ADDREF_P(value);
48039
0
        }
48040
0
      }
48041
180
    } else {
48042
180
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48043
180
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48044
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48045
180
      } else {
48046
180
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48047
180
      }
48048
180
      if (UNEXPECTED(variable_ptr == NULL)) {
48049
29
        goto assign_dim_error;
48050
29
      }
48051
151
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
48052
151
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
48053
151
    }
48054
151
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48055
27
      ZVAL_COPY(EX_VAR(opline->result.var), value);
48056
27
    }
48057
151
    if (garbage) {
48058
124
      GC_DTOR_NO_REF(garbage);
48059
124
    }
48060
238
  } else {
48061
238
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
48062
124
      object_ptr = Z_REFVAL_P(object_ptr);
48063
124
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48064
124
        goto try_assign_dim_array;
48065
124
      }
48066
124
    }
48067
114
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48068
94
      zend_object *obj = Z_OBJ_P(object_ptr);
48069
48070
94
      GC_ADDREF(obj);
48071
94
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48072
94
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48073
0
        dim = ZVAL_UNDEFINED_OP2();
48074
94
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48075
0
        dim++;
48076
0
      }
48077
48078
94
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
48079
94
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48080
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48081
94
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
48082
0
        ZVAL_DEREF(value);
48083
0
      }
48084
48085
94
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48086
48087
94
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48088
0
        zend_objects_store_del(obj);
48089
0
      }
48090
94
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48091
8
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48092
0
        zend_use_new_element_for_string();
48093
48094
0
        UNDEF_RESULT();
48095
8
      } else {
48096
8
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48097
8
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
48098
8
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48099
48100
8
      }
48101
12
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48102
12
      if (Z_ISREF_P(orig_object_ptr)
48103
12
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48104
12
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48105
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48106
48107
0
        UNDEF_RESULT();
48108
12
      } else {
48109
12
        HashTable *ht = zend_new_array(8);
48110
12
        uint8_t old_type = Z_TYPE_P(object_ptr);
48111
48112
12
        ZVAL_ARR(object_ptr, ht);
48113
12
        if (UNEXPECTED(old_type == IS_FALSE)) {
48114
0
          GC_ADDREF(ht);
48115
0
          zend_false_to_array_deprecated();
48116
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48117
0
            zend_array_destroy(ht);
48118
0
            goto assign_dim_error;
48119
0
          }
48120
0
        }
48121
12
        goto try_assign_dim_array;
48122
12
      }
48123
12
    } else {
48124
0
      zend_use_scalar_as_array();
48125
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48126
29
assign_dim_error:
48127
48128
29
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48129
5
        ZVAL_NULL(EX_VAR(opline->result.var));
48130
5
      }
48131
29
    }
48132
114
  }
48133
282
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48134
282
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48135
282
  }
48136
48137
  /* assign_dim has two opcodes! */
48138
282
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48139
282
}
48140
48141
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48142
314
{
48143
314
  USE_OPLINE
48144
314
  zval *object_ptr, *orig_object_ptr;
48145
314
  zval *value;
48146
314
  zval *variable_ptr;
48147
314
  zval *dim;
48148
314
  zend_refcounted *garbage = NULL;
48149
48150
314
  SAVE_OPLINE();
48151
314
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48152
48153
314
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48154
261
try_assign_dim_array:
48155
261
    SEPARATE_ARRAY(object_ptr);
48156
261
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48157
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48158
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48159
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
48160
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48161
0
          GC_ADDREF(ht);
48162
0
        }
48163
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48164
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48165
0
          zend_array_destroy(ht);
48166
0
          goto assign_dim_error;
48167
0
        }
48168
0
      }
48169
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
48170
0
        ZVAL_DEREF(value);
48171
0
      }
48172
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48173
0
      if (UNEXPECTED(value == NULL)) {
48174
0
        zend_cannot_add_element();
48175
0
        goto assign_dim_error;
48176
0
      } else if (IS_TMP_VAR == IS_CV) {
48177
0
        if (Z_REFCOUNTED_P(value)) {
48178
0
          Z_ADDREF_P(value);
48179
0
        }
48180
0
      } else if (IS_TMP_VAR == IS_VAR) {
48181
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
48182
0
        if (Z_ISREF_P(free_op_data)) {
48183
0
          if (Z_REFCOUNTED_P(value)) {
48184
0
            Z_ADDREF_P(value);
48185
0
          }
48186
0
          zval_ptr_dtor_nogc(free_op_data);
48187
0
        }
48188
0
      } else if (IS_TMP_VAR == IS_CONST) {
48189
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48190
0
          Z_ADDREF_P(value);
48191
0
        }
48192
0
      }
48193
261
    } else {
48194
261
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48195
261
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48196
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48197
261
      } else {
48198
261
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48199
261
      }
48200
261
      if (UNEXPECTED(variable_ptr == NULL)) {
48201
0
        goto assign_dim_error;
48202
0
      }
48203
261
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48204
261
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48205
261
    }
48206
261
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48207
42
      ZVAL_COPY(EX_VAR(opline->result.var), value);
48208
42
    }
48209
261
    if (garbage) {
48210
0
      GC_DTOR_NO_REF(garbage);
48211
0
    }
48212
261
  } else {
48213
204
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
48214
124
      object_ptr = Z_REFVAL_P(object_ptr);
48215
124
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48216
124
        goto try_assign_dim_array;
48217
124
      }
48218
124
    }
48219
80
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48220
0
      zend_object *obj = Z_OBJ_P(object_ptr);
48221
48222
0
      GC_ADDREF(obj);
48223
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48224
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48225
0
        dim = ZVAL_UNDEFINED_OP2();
48226
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48227
0
        dim++;
48228
0
      }
48229
48230
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48231
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48232
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48233
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
48234
0
        ZVAL_DEREF(value);
48235
0
      }
48236
48237
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48238
48239
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48240
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48241
0
        zend_objects_store_del(obj);
48242
0
      }
48243
80
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48244
53
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48245
0
        zend_use_new_element_for_string();
48246
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48247
0
        UNDEF_RESULT();
48248
53
      } else {
48249
53
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48250
53
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48251
53
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48252
53
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48253
53
      }
48254
53
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48255
27
      if (Z_ISREF_P(orig_object_ptr)
48256
27
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48257
27
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48258
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48259
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48260
0
        UNDEF_RESULT();
48261
27
      } else {
48262
27
        HashTable *ht = zend_new_array(8);
48263
27
        uint8_t old_type = Z_TYPE_P(object_ptr);
48264
48265
27
        ZVAL_ARR(object_ptr, ht);
48266
27
        if (UNEXPECTED(old_type == IS_FALSE)) {
48267
0
          GC_ADDREF(ht);
48268
0
          zend_false_to_array_deprecated();
48269
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48270
0
            zend_array_destroy(ht);
48271
0
            goto assign_dim_error;
48272
0
          }
48273
0
        }
48274
27
        goto try_assign_dim_array;
48275
27
      }
48276
27
    } else {
48277
0
      zend_use_scalar_as_array();
48278
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48279
0
assign_dim_error:
48280
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48281
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48282
0
        ZVAL_NULL(EX_VAR(opline->result.var));
48283
0
      }
48284
0
    }
48285
80
  }
48286
314
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48287
314
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48288
314
  }
48289
48290
  /* assign_dim has two opcodes! */
48291
314
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48292
314
}
48293
48294
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48295
694
{
48296
694
  USE_OPLINE
48297
694
  zval *object_ptr, *orig_object_ptr;
48298
694
  zval *value;
48299
694
  zval *variable_ptr;
48300
694
  zval *dim;
48301
694
  zend_refcounted *garbage = NULL;
48302
48303
694
  SAVE_OPLINE();
48304
694
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48305
48306
694
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48307
677
try_assign_dim_array:
48308
677
    SEPARATE_ARRAY(object_ptr);
48309
677
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48310
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48311
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48312
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
48313
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48314
0
          GC_ADDREF(ht);
48315
0
        }
48316
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48317
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48318
0
          zend_array_destroy(ht);
48319
0
          goto assign_dim_error;
48320
0
        }
48321
0
      }
48322
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
48323
0
        ZVAL_DEREF(value);
48324
0
      }
48325
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48326
0
      if (UNEXPECTED(value == NULL)) {
48327
0
        zend_cannot_add_element();
48328
0
        goto assign_dim_error;
48329
0
      } else if (IS_VAR == IS_CV) {
48330
0
        if (Z_REFCOUNTED_P(value)) {
48331
0
          Z_ADDREF_P(value);
48332
0
        }
48333
0
      } else if (IS_VAR == IS_VAR) {
48334
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
48335
0
        if (Z_ISREF_P(free_op_data)) {
48336
0
          if (Z_REFCOUNTED_P(value)) {
48337
0
            Z_ADDREF_P(value);
48338
0
          }
48339
0
          zval_ptr_dtor_nogc(free_op_data);
48340
0
        }
48341
0
      } else if (IS_VAR == IS_CONST) {
48342
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48343
0
          Z_ADDREF_P(value);
48344
0
        }
48345
0
      }
48346
677
    } else {
48347
677
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48348
677
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48349
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48350
677
      } else {
48351
677
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48352
677
      }
48353
677
      if (UNEXPECTED(variable_ptr == NULL)) {
48354
3
        goto assign_dim_error;
48355
3
      }
48356
674
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48357
674
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48358
674
    }
48359
674
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48360
26
      ZVAL_COPY(EX_VAR(opline->result.var), value);
48361
26
    }
48362
674
    if (garbage) {
48363
139
      GC_DTOR_NO_REF(garbage);
48364
139
    }
48365
674
  } else {
48366
242
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
48367
0
      object_ptr = Z_REFVAL_P(object_ptr);
48368
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48369
0
        goto try_assign_dim_array;
48370
0
      }
48371
0
    }
48372
242
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48373
7
      zend_object *obj = Z_OBJ_P(object_ptr);
48374
48375
7
      GC_ADDREF(obj);
48376
7
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48377
7
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48378
0
        dim = ZVAL_UNDEFINED_OP2();
48379
7
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48380
0
        dim++;
48381
0
      }
48382
48383
7
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48384
7
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48385
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48386
7
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
48387
7
        ZVAL_DEREF(value);
48388
7
      }
48389
48390
7
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48391
48392
7
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48393
7
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48394
0
        zend_objects_store_del(obj);
48395
0
      }
48396
235
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48397
10
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48398
0
        zend_use_new_element_for_string();
48399
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48400
0
        UNDEF_RESULT();
48401
10
      } else {
48402
10
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48403
10
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48404
10
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48405
10
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48406
10
      }
48407
225
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48408
225
      if (Z_ISREF_P(orig_object_ptr)
48409
225
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48410
225
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48411
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48412
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48413
0
        UNDEF_RESULT();
48414
225
      } else {
48415
225
        HashTable *ht = zend_new_array(8);
48416
225
        uint8_t old_type = Z_TYPE_P(object_ptr);
48417
48418
225
        ZVAL_ARR(object_ptr, ht);
48419
225
        if (UNEXPECTED(old_type == IS_FALSE)) {
48420
0
          GC_ADDREF(ht);
48421
0
          zend_false_to_array_deprecated();
48422
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48423
0
            zend_array_destroy(ht);
48424
0
            goto assign_dim_error;
48425
0
          }
48426
0
        }
48427
225
        goto try_assign_dim_array;
48428
225
      }
48429
225
    } else {
48430
0
      zend_use_scalar_as_array();
48431
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48432
3
assign_dim_error:
48433
3
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48434
3
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48435
0
        ZVAL_NULL(EX_VAR(opline->result.var));
48436
0
      }
48437
3
    }
48438
242
  }
48439
694
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48440
694
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48441
694
  }
48442
48443
  /* assign_dim has two opcodes! */
48444
694
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48445
694
}
48446
48447
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48448
704
{
48449
704
  USE_OPLINE
48450
704
  zval *object_ptr, *orig_object_ptr;
48451
704
  zval *value;
48452
704
  zval *variable_ptr;
48453
704
  zval *dim;
48454
704
  zend_refcounted *garbage = NULL;
48455
48456
704
  SAVE_OPLINE();
48457
704
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48458
48459
704
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48460
704
try_assign_dim_array:
48461
704
    SEPARATE_ARRAY(object_ptr);
48462
704
    if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48463
0
      value = EX_VAR((opline+1)->op1.var);
48464
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48465
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
48466
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48467
0
          GC_ADDREF(ht);
48468
0
        }
48469
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48470
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48471
0
          zend_array_destroy(ht);
48472
0
          goto assign_dim_error;
48473
0
        }
48474
0
      }
48475
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
48476
0
        ZVAL_DEREF(value);
48477
0
      }
48478
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48479
0
      if (UNEXPECTED(value == NULL)) {
48480
0
        zend_cannot_add_element();
48481
0
        goto assign_dim_error;
48482
0
      } else if (IS_CV == IS_CV) {
48483
0
        if (Z_REFCOUNTED_P(value)) {
48484
0
          Z_ADDREF_P(value);
48485
0
        }
48486
0
      } else if (IS_CV == IS_VAR) {
48487
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
48488
0
        if (Z_ISREF_P(free_op_data)) {
48489
0
          if (Z_REFCOUNTED_P(value)) {
48490
0
            Z_ADDREF_P(value);
48491
0
          }
48492
0
          zval_ptr_dtor_nogc(free_op_data);
48493
0
        }
48494
0
      } else if (IS_CV == IS_CONST) {
48495
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48496
0
          Z_ADDREF_P(value);
48497
0
        }
48498
0
      }
48499
704
    } else {
48500
704
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48501
704
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48502
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48503
704
      } else {
48504
704
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48505
704
      }
48506
704
      if (UNEXPECTED(variable_ptr == NULL)) {
48507
0
        goto assign_dim_error;
48508
0
      }
48509
704
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
48510
704
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
48511
704
    }
48512
704
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48513
185
      ZVAL_COPY(EX_VAR(opline->result.var), value);
48514
185
    }
48515
704
    if (garbage) {
48516
0
      GC_DTOR_NO_REF(garbage);
48517
0
    }
48518
704
  } else {
48519
59
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
48520
0
      object_ptr = Z_REFVAL_P(object_ptr);
48521
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48522
0
        goto try_assign_dim_array;
48523
0
      }
48524
0
    }
48525
59
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48526
0
      zend_object *obj = Z_OBJ_P(object_ptr);
48527
48528
0
      GC_ADDREF(obj);
48529
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48530
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48531
0
        dim = ZVAL_UNDEFINED_OP2();
48532
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48533
0
        dim++;
48534
0
      }
48535
48536
0
      value = EX_VAR((opline+1)->op1.var);
48537
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48538
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48539
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
48540
0
        ZVAL_DEREF(value);
48541
0
      }
48542
48543
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48544
48545
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48546
0
        zend_objects_store_del(obj);
48547
0
      }
48548
59
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48549
0
      if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48550
0
        zend_use_new_element_for_string();
48551
48552
0
        UNDEF_RESULT();
48553
0
      } else {
48554
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48555
0
        value = EX_VAR((opline+1)->op1.var);
48556
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48557
48558
0
      }
48559
59
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48560
59
      if (Z_ISREF_P(orig_object_ptr)
48561
59
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48562
59
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48563
0
        dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48564
48565
0
        UNDEF_RESULT();
48566
59
      } else {
48567
59
        HashTable *ht = zend_new_array(8);
48568
59
        uint8_t old_type = Z_TYPE_P(object_ptr);
48569
48570
59
        ZVAL_ARR(object_ptr, ht);
48571
59
        if (UNEXPECTED(old_type == IS_FALSE)) {
48572
0
          GC_ADDREF(ht);
48573
0
          zend_false_to_array_deprecated();
48574
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48575
0
            zend_array_destroy(ht);
48576
0
            goto assign_dim_error;
48577
0
          }
48578
0
        }
48579
59
        goto try_assign_dim_array;
48580
59
      }
48581
59
    } else {
48582
0
      zend_use_scalar_as_array();
48583
0
      dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48584
0
assign_dim_error:
48585
48586
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48587
0
        ZVAL_NULL(EX_VAR(opline->result.var));
48588
0
      }
48589
0
    }
48590
59
  }
48591
704
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48592
704
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48593
704
  }
48594
48595
  /* assign_dim has two opcodes! */
48596
704
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48597
704
}
48598
48599
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48600
0
{
48601
0
  USE_OPLINE
48602
0
  zval *property, *container, *value_ptr;
48603
48604
0
  SAVE_OPLINE();
48605
48606
0
  container = EX_VAR(opline->op1.var);
48607
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48608
48609
0
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48610
48611
0
  if (1) {
48612
0
    if (IS_CV == IS_UNUSED) {
48613
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48614
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48615
0
      } else {
48616
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48617
0
      }
48618
0
    } else {
48619
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48620
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48621
0
      } else {
48622
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48623
0
      }
48624
0
    }
48625
0
  } else {
48626
0
    zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
48627
0
  }
48628
48629
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48630
0
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48631
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48632
0
}
48633
48634
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
48635
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48636
0
{
48637
0
  USE_OPLINE
48638
0
  zval *property, *container, *value_ptr;
48639
48640
0
  SAVE_OPLINE();
48641
48642
0
  container = EX_VAR(opline->op1.var);
48643
0
  property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48644
48645
0
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
48646
48647
0
  if (1) {
48648
0
    if (IS_CV == IS_UNUSED) {
48649
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48650
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48651
0
      } else {
48652
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48653
0
      }
48654
0
    } else {
48655
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48656
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48657
0
      } else {
48658
0
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48659
0
      }
48660
0
    }
48661
0
  } else {
48662
0
    zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
48663
0
  }
48664
48665
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48666
48667
0
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
48668
0
}
48669
48670
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
48671
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48672
1.34k
{
48673
1.34k
  USE_OPLINE
48674
1.34k
  zval *op1, *op2;
48675
1.34k
  zend_string *op1_str, *op2_str, *str;
48676
48677
48678
1.34k
  op1 = EX_VAR(opline->op1.var);
48679
1.34k
  op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48680
1.34k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
48681
1.34k
      ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
48682
30
    zend_string *op1_str = Z_STR_P(op1);
48683
30
    zend_string *op2_str = Z_STR_P(op2);
48684
30
    zend_string *str;
48685
30
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
48686
48687
30
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
48688
0
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
48689
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
48690
0
      } else {
48691
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
48692
0
      }
48693
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
48694
0
        zend_string_release_ex(op1_str, 0);
48695
0
      }
48696
30
    } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
48697
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
48698
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
48699
0
      } else {
48700
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
48701
0
      }
48702
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48703
0
        zend_string_release_ex(op2_str, 0);
48704
0
      }
48705
30
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
48706
30
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
48707
0
      size_t len = ZSTR_LEN(op1_str);
48708
48709
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
48710
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48711
0
      GC_ADD_FLAGS(str, flags);
48712
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48713
0
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48714
0
        zend_string_release_ex(op2_str, 0);
48715
0
      }
48716
30
    } else {
48717
30
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
48718
30
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
48719
30
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48720
30
      GC_ADD_FLAGS(str, flags);
48721
30
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48722
30
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
48723
0
        zend_string_release_ex(op1_str, 0);
48724
0
      }
48725
30
      if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48726
30
        zend_string_release_ex(op2_str, 0);
48727
30
      }
48728
30
    }
48729
30
    ZEND_VM_NEXT_OPCODE();
48730
30
  }
48731
48732
1.34k
  SAVE_OPLINE();
48733
1.31k
  if (IS_CV == IS_CONST) {
48734
0
    op1_str = Z_STR_P(op1);
48735
1.31k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
48736
755
    op1_str = zend_string_copy(Z_STR_P(op1));
48737
755
  } else {
48738
563
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
48739
352
      ZVAL_UNDEFINED_OP1();
48740
352
    }
48741
563
    op1_str = zval_get_string_func(op1);
48742
563
  }
48743
1.31k
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48744
0
    op2_str = Z_STR_P(op2);
48745
1.31k
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
48746
7
    op2_str = zend_string_copy(Z_STR_P(op2));
48747
1.31k
  } else {
48748
1.31k
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
48749
0
      ZVAL_UNDEFINED_OP2();
48750
0
    }
48751
1.31k
    op2_str = zval_get_string_func(op2);
48752
1.31k
  }
48753
1.31k
  do {
48754
1.31k
    if (IS_CV != IS_CONST) {
48755
1.31k
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
48756
379
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48757
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
48758
0
            GC_ADDREF(op2_str);
48759
0
          }
48760
0
        }
48761
379
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
48762
379
        zend_string_release_ex(op1_str, 0);
48763
379
        break;
48764
379
      }
48765
1.31k
    }
48766
939
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48767
939
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
48768
50
        if (IS_CV == IS_CONST) {
48769
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
48770
0
            GC_ADDREF(op1_str);
48771
0
          }
48772
0
        }
48773
50
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
48774
50
        zend_string_release_ex(op2_str, 0);
48775
50
        break;
48776
50
      }
48777
939
    }
48778
889
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
48779
889
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
48780
889
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48781
48782
889
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
48783
889
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48784
889
    if (IS_CV != IS_CONST) {
48785
889
      zend_string_release_ex(op1_str, 0);
48786
889
    }
48787
889
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48788
889
      zend_string_release_ex(op2_str, 0);
48789
889
    }
48790
889
  } while (0);
48791
48792
1.31k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48793
1.31k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48794
1.31k
}
48795
48796
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48797
61
{
48798
61
  USE_OPLINE
48799
61
  zval *function_name;
48800
61
  zval *object;
48801
61
  zend_function *fbc;
48802
61
  zend_class_entry *called_scope;
48803
61
  zend_object *obj;
48804
61
  zend_execute_data *call;
48805
61
  uint32_t call_info;
48806
48807
61
  SAVE_OPLINE();
48808
48809
61
  object = EX_VAR(opline->op1.var);
48810
48811
61
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48812
61
    function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48813
61
  }
48814
48815
61
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
48816
61
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
48817
2
    do {
48818
2
      if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
48819
0
        function_name = Z_REFVAL_P(function_name);
48820
0
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
48821
0
          break;
48822
0
        }
48823
2
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
48824
0
        ZVAL_UNDEFINED_OP2();
48825
0
        if (UNEXPECTED(EG(exception) != NULL)) {
48826
48827
0
          HANDLE_EXCEPTION();
48828
0
        }
48829
0
      }
48830
2
      zend_throw_error(NULL, "Method name must be a string");
48831
2
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48832
48833
2
      HANDLE_EXCEPTION();
48834
2
    } while (0);
48835
2
  }
48836
48837
59
  if (IS_CV == IS_UNUSED) {
48838
0
    obj = Z_OBJ_P(object);
48839
59
  } else {
48840
59
    do {
48841
59
      if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
48842
59
        obj = Z_OBJ_P(object);
48843
59
      } else {
48844
0
        if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
48845
0
          zend_reference *ref = Z_REF_P(object);
48846
48847
0
          object = &ref->val;
48848
0
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
48849
0
            obj = Z_OBJ_P(object);
48850
0
            if (IS_CV & IS_VAR) {
48851
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
48852
0
                efree_size(ref, sizeof(zend_reference));
48853
0
              } else {
48854
0
                Z_ADDREF_P(object);
48855
0
              }
48856
0
            }
48857
0
            break;
48858
0
          }
48859
0
        }
48860
0
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
48861
0
          object = ZVAL_UNDEFINED_OP1();
48862
0
          if (UNEXPECTED(EG(exception) != NULL)) {
48863
0
            if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48864
0
              zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48865
0
            }
48866
0
            HANDLE_EXCEPTION();
48867
0
          }
48868
0
        }
48869
0
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48870
0
          function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48871
0
        }
48872
0
        zend_invalid_method_call(object, function_name);
48873
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48874
48875
0
        HANDLE_EXCEPTION();
48876
0
      }
48877
59
    } while (0);
48878
59
  }
48879
48880
59
  called_scope = obj->ce;
48881
48882
59
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
48883
59
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
48884
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
48885
59
  } else {
48886
59
    zend_object *orig_obj = obj;
48887
48888
59
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48889
0
      function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48890
0
    }
48891
48892
    /* First, locate the function. */
48893
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));
48894
59
    if (UNEXPECTED(fbc == NULL)) {
48895
0
      if (EXPECTED(!EG(exception))) {
48896
0
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
48897
0
      }
48898
0
      zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48899
0
      if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
48900
0
        zend_objects_store_del(orig_obj);
48901
0
      }
48902
0
      HANDLE_EXCEPTION();
48903
0
    }
48904
59
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
48905
59
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
48906
59
        EXPECTED(obj == orig_obj)) {
48907
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
48908
0
    }
48909
59
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
48910
0
      GC_ADDREF(obj); /* For $this pointer */
48911
0
      if (GC_DELREF(orig_obj) == 0) {
48912
0
        zend_objects_store_del(orig_obj);
48913
0
      }
48914
0
    }
48915
59
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
48916
24
      init_func_run_time_cache(&fbc->op_array);
48917
24
    }
48918
59
  }
48919
48920
59
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48921
59
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48922
59
  }
48923
48924
59
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
48925
59
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
48926
0
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
48927
0
      zend_objects_store_del(obj);
48928
0
      if (UNEXPECTED(EG(exception))) {
48929
0
        HANDLE_EXCEPTION();
48930
0
      }
48931
0
    }
48932
    /* call static method */
48933
0
    obj = (zend_object*)called_scope;
48934
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
48935
59
  } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
48936
59
    if (IS_CV == IS_CV) {
48937
59
      GC_ADDREF(obj); /* For $this pointer */
48938
59
    }
48939
    /* CV may be changed indirectly (e.g. when it's a reference) */
48940
59
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
48941
59
  }
48942
48943
59
  call = zend_vm_stack_push_call_frame(call_info,
48944
59
    fbc, opline->extended_value, obj);
48945
59
  call->prev_execute_data = EX(call);
48946
59
  EX(call) = call;
48947
48948
59
  ZEND_VM_NEXT_OPCODE();
48949
59
}
48950
48951
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48952
4
{
48953
4
  USE_OPLINE
48954
4
  zval *expr_ptr, new_expr;
48955
48956
4
  SAVE_OPLINE();
48957
4
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
48958
4
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
48959
4
    expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
48960
4
    if (Z_ISREF_P(expr_ptr)) {
48961
0
      Z_ADDREF_P(expr_ptr);
48962
4
    } else {
48963
4
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
48964
4
    }
48965
48966
4
  } else {
48967
0
    expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48968
0
    if (IS_CV == IS_TMP_VAR) {
48969
      /* pass */
48970
0
    } else if (IS_CV == IS_CONST) {
48971
0
      Z_TRY_ADDREF_P(expr_ptr);
48972
0
    } else if (IS_CV == IS_CV) {
48973
0
      ZVAL_DEREF(expr_ptr);
48974
0
      Z_TRY_ADDREF_P(expr_ptr);
48975
0
    } else /* if (IS_CV == IS_VAR) */ {
48976
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
48977
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
48978
48979
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
48980
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
48981
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
48982
0
          expr_ptr = &new_expr;
48983
0
          efree_size(ref, sizeof(zend_reference));
48984
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
48985
0
          Z_ADDREF_P(expr_ptr);
48986
0
        }
48987
0
      }
48988
0
    }
48989
0
  }
48990
48991
4
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48992
4
    zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48993
4
    zend_string *str;
48994
4
    zend_ulong hval;
48995
48996
4
add_again:
48997
4
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
48998
0
      str = Z_STR_P(offset);
48999
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49000
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
49001
0
          goto num_index;
49002
0
        }
49003
0
      }
49004
0
str_index:
49005
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
49006
4
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49007
4
      hval = Z_LVAL_P(offset);
49008
4
num_index:
49009
4
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
49010
4
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
49011
0
      offset = Z_REFVAL_P(offset);
49012
0
      goto add_again;
49013
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
49014
0
      str = ZSTR_EMPTY_ALLOC();
49015
0
      goto str_index;
49016
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
49017
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
49018
0
      goto num_index;
49019
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
49020
0
      hval = 0;
49021
0
      goto num_index;
49022
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
49023
0
      hval = 1;
49024
0
      goto num_index;
49025
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
49026
0
      zend_use_resource_as_offset(offset);
49027
0
      hval = Z_RES_HANDLE_P(offset);
49028
0
      goto num_index;
49029
0
    } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
49030
0
      ZVAL_UNDEFINED_OP2();
49031
0
      str = ZSTR_EMPTY_ALLOC();
49032
0
      goto str_index;
49033
0
    } else {
49034
0
      zend_illegal_array_offset_access(offset);
49035
0
      zval_ptr_dtor_nogc(expr_ptr);
49036
0
    }
49037
4
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49038
4
  } else {
49039
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
49040
0
      zend_cannot_add_element();
49041
0
      zval_ptr_dtor_nogc(expr_ptr);
49042
0
    }
49043
0
  }
49044
4
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49045
4
}
49046
49047
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49048
0
{
49049
0
  zval *array;
49050
0
  uint32_t size;
49051
0
  USE_OPLINE
49052
49053
0
  SAVE_OPLINE();
49054
0
  array = EX_VAR(opline->result.var);
49055
0
  if (IS_CV != IS_UNUSED) {
49056
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
49057
0
    ZVAL_ARR(array, zend_new_array(size));
49058
    /* Explicitly initialize array as not-packed if flag is set */
49059
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
49060
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
49061
0
    }
49062
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49063
0
  } else {
49064
0
    ZVAL_ARR(array, zend_new_array(0));
49065
0
    ZEND_VM_NEXT_OPCODE();
49066
0
  }
49067
0
}
49068
49069
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49070
493
{
49071
493
  USE_OPLINE
49072
493
  zval *container;
49073
493
  zval *offset;
49074
493
  zend_ulong hval;
49075
493
  zend_string *key;
49076
49077
493
  SAVE_OPLINE();
49078
493
  container = EX_VAR(opline->op1.var);
49079
493
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49080
49081
493
  do {
49082
493
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49083
452
      HashTable *ht;
49084
49085
452
unset_dim_array:
49086
452
      SEPARATE_ARRAY(container);
49087
452
      ht = Z_ARRVAL_P(container);
49088
452
offset_again:
49089
452
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49090
5
        key = Z_STR_P(offset);
49091
5
        if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49092
5
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
49093
0
            goto num_index_dim;
49094
0
          }
49095
5
        }
49096
17
str_index_dim:
49097
17
        ZEND_ASSERT(ht != &EG(symbol_table));
49098
17
        zend_hash_del(ht, key);
49099
447
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49100
398
        hval = Z_LVAL_P(offset);
49101
435
num_index_dim:
49102
435
        zend_hash_index_del(ht, hval);
49103
435
      } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
49104
0
        offset = Z_REFVAL_P(offset);
49105
0
        goto offset_again;
49106
49
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
49107
37
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
49108
37
        goto num_index_dim;
49109
37
      } else if (Z_TYPE_P(offset) == IS_NULL) {
49110
12
        key = ZSTR_EMPTY_ALLOC();
49111
12
        goto str_index_dim;
49112
12
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
49113
0
        hval = 0;
49114
0
        goto num_index_dim;
49115
0
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
49116
0
        hval = 1;
49117
0
        goto num_index_dim;
49118
0
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
49119
0
        zend_use_resource_as_offset(offset);
49120
0
        hval = Z_RES_HANDLE_P(offset);
49121
0
        goto num_index_dim;
49122
0
      } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
49123
0
        ZVAL_UNDEFINED_OP2();
49124
0
        key = ZSTR_EMPTY_ALLOC();
49125
0
        goto str_index_dim;
49126
0
      } else {
49127
0
        zend_illegal_array_offset_unset(offset);
49128
0
      }
49129
452
      break;
49130
452
    } else if (Z_ISREF_P(container)) {
49131
0
      container = Z_REFVAL_P(container);
49132
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49133
0
        goto unset_dim_array;
49134
0
      }
49135
0
    }
49136
41
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
49137
6
      container = ZVAL_UNDEFINED_OP1();
49138
6
    }
49139
41
    if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
49140
0
      offset = ZVAL_UNDEFINED_OP2();
49141
0
    }
49142
41
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
49143
35
      if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
49144
0
        offset++;
49145
0
      }
49146
35
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
49147
35
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
49148
0
      zend_throw_error(NULL, "Cannot unset string offsets");
49149
6
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
49150
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
49151
6
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
49152
0
      zend_false_to_array_deprecated();
49153
0
    }
49154
41
  } while (0);
49155
49156
493
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49157
49158
493
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49159
493
}
49160
49161
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49162
0
{
49163
0
  USE_OPLINE
49164
0
  zval *container;
49165
0
  zval *offset;
49166
0
  zend_string *name, *tmp_name;
49167
49168
0
  SAVE_OPLINE();
49169
0
  container = EX_VAR(opline->op1.var);
49170
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49171
49172
0
  do {
49173
0
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
49174
0
      if (Z_ISREF_P(container)) {
49175
0
        container = Z_REFVAL_P(container);
49176
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
49177
0
          if (IS_CV == IS_CV
49178
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
49179
0
            ZVAL_UNDEFINED_OP1();
49180
0
          }
49181
0
          break;
49182
0
        }
49183
0
      } else {
49184
0
        break;
49185
0
      }
49186
0
    }
49187
0
    if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
49188
0
      name = Z_STR_P(offset);
49189
0
    } else {
49190
0
      name = zval_try_get_tmp_string(offset, &tmp_name);
49191
0
      if (UNEXPECTED(!name)) {
49192
0
        break;
49193
0
      }
49194
0
    }
49195
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));
49196
0
    if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49197
0
      zend_tmp_string_release(tmp_name);
49198
0
    }
49199
0
  } while (0);
49200
49201
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49202
49203
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49204
0
}
49205
49206
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49207
193
{
49208
193
  USE_OPLINE
49209
193
  zval *container;
49210
193
  bool result;
49211
193
  zend_ulong hval;
49212
193
  zval *offset;
49213
49214
193
  SAVE_OPLINE();
49215
193
  container = EX_VAR(opline->op1.var);
49216
193
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49217
49218
193
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49219
21
    HashTable *ht;
49220
21
    zval *value;
49221
21
    zend_string *str;
49222
49223
21
isset_dim_obj_array:
49224
21
    ht = Z_ARRVAL_P(container);
49225
21
isset_again:
49226
21
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49227
0
      str = Z_STR_P(offset);
49228
0
      if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49229
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
49230
0
          goto num_index_prop;
49231
0
        }
49232
0
      }
49233
0
      value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
49234
21
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49235
0
      hval = Z_LVAL_P(offset);
49236
0
num_index_prop:
49237
0
      value = zend_hash_index_find(ht, hval);
49238
21
    } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
49239
0
      offset = Z_REFVAL_P(offset);
49240
0
      goto isset_again;
49241
21
    } else {
49242
21
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
49243
21
      if (UNEXPECTED(EG(exception))) {
49244
21
        result = 0;
49245
21
        goto isset_dim_obj_exit;
49246
21
      }
49247
21
    }
49248
49249
0
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
49250
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
49251
0
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
49252
0
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
49253
49254
0
      if (IS_CV & (IS_CONST|IS_CV)) {
49255
        /* avoid exception check */
49256
0
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49257
0
        ZEND_VM_SMART_BRANCH(result, 0);
49258
0
      }
49259
0
    } else {
49260
0
      result = (value == NULL || !i_zend_is_true(value));
49261
0
    }
49262
0
    goto isset_dim_obj_exit;
49263
172
  } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
49264
0
    container = Z_REFVAL_P(container);
49265
0
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49266
0
      goto isset_dim_obj_array;
49267
0
    }
49268
0
  }
49269
49270
172
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
49271
0
    offset++;
49272
0
  }
49273
172
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
49274
86
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
49275
86
  } else {
49276
86
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
49277
86
  }
49278
49279
193
isset_dim_obj_exit:
49280
193
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49281
49282
193
  ZEND_VM_SMART_BRANCH(result, 1);
49283
193
}
49284
49285
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49286
0
{
49287
0
  USE_OPLINE
49288
0
  zval *container;
49289
0
  int result;
49290
0
  zval *offset;
49291
0
  zend_string *name, *tmp_name;
49292
49293
0
  SAVE_OPLINE();
49294
0
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
49295
0
  offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49296
49297
0
  if (IS_CV == IS_CONST ||
49298
0
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
49299
0
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
49300
0
      container = Z_REFVAL_P(container);
49301
0
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
49302
0
        result = (opline->extended_value & ZEND_ISEMPTY);
49303
0
        goto isset_object_finish;
49304
0
      }
49305
0
    } else {
49306
0
      result = (opline->extended_value & ZEND_ISEMPTY);
49307
0
      goto isset_object_finish;
49308
0
    }
49309
0
  }
49310
49311
0
  if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
49312
0
    name = Z_STR_P(offset);
49313
0
  } else {
49314
0
    name = zval_try_get_tmp_string(offset, &tmp_name);
49315
0
    if (UNEXPECTED(!name)) {
49316
0
      result = 0;
49317
0
      goto isset_object_finish;
49318
0
    }
49319
0
  }
49320
49321
0
  result =
49322
0
    (opline->extended_value & ZEND_ISEMPTY) ^
49323
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));
49324
49325
0
  if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49326
0
    zend_tmp_string_release(tmp_name);
49327
0
  }
49328
49329
0
isset_object_finish:
49330
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49331
49332
0
  ZEND_VM_SMART_BRANCH(result, 1);
49333
0
}
49334
49335
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49336
339
{
49337
339
  USE_OPLINE
49338
49339
339
  zval *key, *subject;
49340
339
  HashTable *ht;
49341
339
  bool result;
49342
49343
339
  SAVE_OPLINE();
49344
49345
339
  key = EX_VAR(opline->op1.var);
49346
339
  subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49347
49348
339
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
49349
333
array_key_exists_array:
49350
333
    ht = Z_ARRVAL_P(subject);
49351
333
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
49352
333
  } else {
49353
6
    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
49354
0
      subject = Z_REFVAL_P(subject);
49355
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
49356
0
        goto array_key_exists_array;
49357
0
      }
49358
0
    }
49359
6
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
49360
6
    result = 0;
49361
6
  }
49362
49363
339
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49364
49365
339
  ZEND_VM_SMART_BRANCH(result, 1);
49366
339
}
49367
49368
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49369
0
{
49370
0
  USE_OPLINE
49371
49372
0
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
49373
49374
0
  SAVE_OPLINE();
49375
0
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
49376
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49377
0
  }
49378
49379
  /* Destroy the previously yielded value */
49380
0
  zval_ptr_dtor(&generator->value);
49381
49382
  /* Destroy the previously yielded key */
49383
0
  zval_ptr_dtor(&generator->key);
49384
49385
  /* Set the new yielded value */
49386
0
  if (IS_CV != IS_UNUSED) {
49387
0
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
49388
      /* Constants and temporary variables aren't yieldable by reference,
49389
       * but we still allow them with a notice. */
49390
0
      if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
49391
0
        zval *value;
49392
49393
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49394
49395
0
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49396
0
        ZVAL_COPY_VALUE(&generator->value, value);
49397
0
        if (IS_CV == IS_CONST) {
49398
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49399
0
            Z_ADDREF(generator->value);
49400
0
          }
49401
0
        }
49402
0
      } else {
49403
0
        zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49404
49405
        /* If a function call result is yielded and the function did
49406
         * not return by reference we throw a notice. */
49407
0
        do {
49408
0
          if (IS_CV == IS_VAR) {
49409
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
49410
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
49411
0
             && !Z_ISREF_P(value_ptr)) {
49412
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49413
0
              ZVAL_COPY(&generator->value, value_ptr);
49414
0
              break;
49415
0
            }
49416
0
          }
49417
0
          if (Z_ISREF_P(value_ptr)) {
49418
0
            Z_ADDREF_P(value_ptr);
49419
0
          } else {
49420
0
            ZVAL_MAKE_REF_EX(value_ptr, 2);
49421
0
          }
49422
0
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
49423
0
        } while (0);
49424
49425
0
      }
49426
0
    } else {
49427
0
      zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49428
49429
      /* Consts, temporary variables and references need copying */
49430
0
      if (IS_CV == IS_CONST) {
49431
0
        ZVAL_COPY_VALUE(&generator->value, value);
49432
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49433
0
          Z_ADDREF(generator->value);
49434
0
        }
49435
0
      } else if (IS_CV == IS_TMP_VAR) {
49436
0
        ZVAL_COPY_VALUE(&generator->value, value);
49437
0
      } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
49438
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
49439
49440
0
      } else {
49441
0
        ZVAL_COPY_VALUE(&generator->value, value);
49442
0
        if (IS_CV == IS_CV) {
49443
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
49444
0
        }
49445
0
      }
49446
0
    }
49447
0
  } else {
49448
    /* If no value was specified yield null */
49449
0
    ZVAL_NULL(&generator->value);
49450
0
  }
49451
49452
  /* Set the new yielded key */
49453
0
  if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
49454
0
    zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49455
0
    if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
49456
0
      key = Z_REFVAL_P(key);
49457
0
    }
49458
0
    ZVAL_COPY(&generator->key, key);
49459
0
    zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49460
49461
0
    if (Z_TYPE(generator->key) == IS_LONG
49462
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
49463
0
    ) {
49464
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
49465
0
    }
49466
0
  } else {
49467
    /* If no key was specified we use auto-increment keys */
49468
0
    generator->largest_used_integer_key++;
49469
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
49470
0
  }
49471
49472
0
  if (RETURN_VALUE_USED(opline)) {
49473
    /* If the return value of yield is used set the send
49474
     * target and initialize it to NULL */
49475
0
    generator->send_target = EX_VAR(opline->result.var);
49476
0
    ZVAL_NULL(generator->send_target);
49477
0
  } else {
49478
0
    generator->send_target = NULL;
49479
0
  }
49480
49481
  /* The GOTO VM uses a local opline variable. We need to set the opline
49482
   * variable in execute_data so we don't resume at an old position. */
49483
0
  SAVE_OPLINE();
49484
49485
0
  ZEND_VM_RETURN();
49486
0
}
49487
49488
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49489
1.08k
{
49490
1.08k
  USE_OPLINE
49491
1.08k
  zval *op1, *op2;
49492
1.08k
  bool result;
49493
49494
1.08k
  SAVE_OPLINE();
49495
1.08k
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49496
1.08k
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49497
1.08k
  result = fast_is_identical_function(op1, op2);
49498
49499
1.08k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49500
1.08k
  ZEND_VM_SMART_BRANCH(result, 1);
49501
1.08k
}
49502
49503
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49504
0
{
49505
0
  USE_OPLINE
49506
0
  zval *op1, *op2;
49507
0
  bool result;
49508
49509
0
  SAVE_OPLINE();
49510
0
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49511
0
  op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49512
0
  result = fast_is_not_identical_function(op1, op2);
49513
49514
0
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49515
0
  ZEND_VM_SMART_BRANCH(result, 1);
49516
0
}
49517
49518
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49519
108k
{
49520
108k
  USE_OPLINE
49521
108k
  zval *value;
49522
108k
  zval *variable_ptr;
49523
49524
108k
  SAVE_OPLINE();
49525
108k
  value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49526
108k
  variable_ptr = EX_VAR(opline->op1.var);
49527
49528
108k
  if (0 || UNEXPECTED(0)) {
49529
0
    zend_refcounted *garbage = NULL;
49530
49531
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
49532
0
    if (UNEXPECTED(0)) {
49533
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
49534
0
    }
49535
0
    if (garbage) {
49536
0
      GC_DTOR_NO_REF(garbage);
49537
0
    }
49538
108k
  } else {
49539
108k
    value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
49540
108k
  }
49541
49542
  /* zend_assign_to_variable() always takes care of op2, never free it! */
49543
49544
108k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49545
108k
}
49546
49547
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49548
902k
{
49549
902k
  USE_OPLINE
49550
902k
  zval *value;
49551
902k
  zval *variable_ptr;
49552
49553
902k
  SAVE_OPLINE();
49554
902k
  value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49555
902k
  variable_ptr = EX_VAR(opline->op1.var);
49556
49557
902k
  if (0 || UNEXPECTED(1)) {
49558
902k
    zend_refcounted *garbage = NULL;
49559
49560
902k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
49561
902k
    if (UNEXPECTED(1)) {
49562
902k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
49563
902k
    }
49564
902k
    if (garbage) {
49565
278k
      GC_DTOR_NO_REF(garbage);
49566
278k
    }
49567
902k
  } else {
49568
0
    value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
49569
0
  }
49570
49571
  /* zend_assign_to_variable() always takes care of op2, never free it! */
49572
49573
902k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49574
902k
}
49575
49576
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49577
93
{
49578
93
  USE_OPLINE
49579
93
  zval *op1, *op2;
49580
93
  bool result;
49581
49582
93
  SAVE_OPLINE();
49583
93
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49584
93
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
49585
93
  result = fast_is_identical_function(op1, op2);
49586
49587
93
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49588
93
  ZEND_VM_SMART_BRANCH(result, 1);
49589
93
}
49590
49591
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49592
57
{
49593
57
  USE_OPLINE
49594
57
  zval *op1, *op2;
49595
57
  bool result;
49596
49597
57
  SAVE_OPLINE();
49598
57
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49599
57
  op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
49600
57
  result = fast_is_not_identical_function(op1, op2);
49601
49602
57
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49603
57
  ZEND_VM_SMART_BRANCH(result, 1);
49604
57
}
49605
49606
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49607
404k
{
49608
404k
  USE_OPLINE
49609
404k
  zval *value;
49610
404k
  zval *variable_ptr;
49611
49612
404k
  SAVE_OPLINE();
49613
404k
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49614
404k
  variable_ptr = EX_VAR(opline->op1.var);
49615
49616
404k
  if (0 || UNEXPECTED(0)) {
49617
0
    zend_refcounted *garbage = NULL;
49618
49619
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
49620
0
    if (UNEXPECTED(0)) {
49621
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
49622
0
    }
49623
0
    if (garbage) {
49624
0
      GC_DTOR_NO_REF(garbage);
49625
0
    }
49626
404k
  } else {
49627
404k
    value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
49628
404k
  }
49629
49630
  /* zend_assign_to_variable() always takes care of op2, never free it! */
49631
49632
404k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49633
404k
}
49634
49635
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49636
874
{
49637
874
  USE_OPLINE
49638
874
  zval *value;
49639
874
  zval *variable_ptr;
49640
49641
874
  SAVE_OPLINE();
49642
874
  value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49643
874
  variable_ptr = EX_VAR(opline->op1.var);
49644
49645
874
  if (0 || UNEXPECTED(1)) {
49646
874
    zend_refcounted *garbage = NULL;
49647
49648
874
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
49649
874
    if (UNEXPECTED(1)) {
49650
874
      ZVAL_COPY(EX_VAR(opline->result.var), value);
49651
874
    }
49652
874
    if (garbage) {
49653
452
      GC_DTOR_NO_REF(garbage);
49654
452
    }
49655
874
  } else {
49656
0
    value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
49657
0
  }
49658
49659
  /* zend_assign_to_variable() always takes care of op2, never free it! */
49660
49661
874
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49662
874
}
49663
49664
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49665
2.64k
{
49666
2.64k
  USE_OPLINE
49667
2.64k
  zval *variable_ptr;
49668
2.64k
  zval *value_ptr;
49669
2.64k
  zend_refcounted *garbage = NULL;
49670
49671
2.64k
  SAVE_OPLINE();
49672
2.64k
  value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49673
2.64k
  variable_ptr = EX_VAR(opline->op1.var);
49674
49675
2.64k
  if (IS_CV == IS_VAR &&
49676
2.64k
             UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
49677
49678
0
    zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
49679
0
    variable_ptr = &EG(uninitialized_zval);
49680
2.64k
  } else if (IS_VAR == IS_VAR &&
49681
2.64k
             opline->extended_value == ZEND_RETURNS_FUNCTION &&
49682
2.64k
         UNEXPECTED(!Z_ISREF_P(value_ptr))) {
49683
49684
43
    variable_ptr = zend_wrong_assign_to_variable_reference(
49685
43
      variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
49686
2.60k
  } else {
49687
2.60k
    zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
49688
2.60k
  }
49689
49690
2.64k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49691
93
    ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
49692
93
  }
49693
49694
2.64k
  if (garbage) {
49695
1.51k
    GC_DTOR(garbage);
49696
1.51k
  }
49697
49698
2.64k
  zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49699
49700
2.64k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49701
2.64k
}
49702
49703
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49704
15
{
49705
15
  USE_OPLINE
49706
15
  zval *expr;
49707
15
  bool result;
49708
49709
15
  SAVE_OPLINE();
49710
15
  expr = EX_VAR(opline->op1.var);
49711
49712
15
try_instanceof:
49713
15
  if (Z_TYPE_P(expr) == IS_OBJECT) {
49714
10
    zend_class_entry *ce;
49715
49716
10
    if (IS_VAR == IS_CONST) {
49717
0
      ce = CACHED_PTR(opline->extended_value);
49718
0
      if (UNEXPECTED(ce == NULL)) {
49719
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);
49720
0
        if (EXPECTED(ce)) {
49721
0
          CACHE_PTR(opline->extended_value, ce);
49722
0
        }
49723
0
      }
49724
10
    } else if (IS_VAR == IS_UNUSED) {
49725
0
      ce = zend_fetch_class(NULL, opline->op2.num);
49726
0
      if (UNEXPECTED(ce == NULL)) {
49727
49728
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
49729
0
        HANDLE_EXCEPTION();
49730
0
      }
49731
10
    } else {
49732
10
      ce = Z_CE_P(EX_VAR(opline->op2.var));
49733
10
    }
49734
10
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
49735
10
  } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
49736
0
    expr = Z_REFVAL_P(expr);
49737
0
    goto try_instanceof;
49738
5
  } else {
49739
5
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
49740
5
      ZVAL_UNDEFINED_OP1();
49741
5
    }
49742
5
    result = 0;
49743
5
  }
49744
49745
15
  ZEND_VM_SMART_BRANCH(result, 1);
49746
15
}
49747
49748
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49749
423
{
49750
423
  USE_OPLINE
49751
423
  zval *var_ptr;
49752
423
  zval *value, *container, *dim;
49753
423
  HashTable *ht;
49754
49755
423
  SAVE_OPLINE();
49756
423
  container = EX_VAR(opline->op1.var);
49757
49758
423
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49759
343
assign_dim_op_array:
49760
343
    SEPARATE_ARRAY(container);
49761
343
    ht = Z_ARRVAL_P(container);
49762
411
assign_dim_op_new_array:
49763
411
    dim = NULL;
49764
411
    if (IS_UNUSED == IS_UNUSED) {
49765
411
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
49766
411
      if (UNEXPECTED(!var_ptr)) {
49767
19
        zend_cannot_add_element();
49768
19
        goto assign_dim_op_ret_null;
49769
19
      }
49770
411
    } else {
49771
0
      if (IS_UNUSED == IS_CONST) {
49772
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
49773
0
      } else {
49774
0
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
49775
0
      }
49776
0
      if (UNEXPECTED(!var_ptr)) {
49777
0
        goto assign_dim_op_ret_null;
49778
0
      }
49779
0
    }
49780
49781
392
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
49782
49783
392
    do {
49784
392
      if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
49785
0
        zend_reference *ref = Z_REF_P(var_ptr);
49786
0
        var_ptr = Z_REFVAL_P(var_ptr);
49787
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
49788
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
49789
0
          break;
49790
0
        }
49791
0
      }
49792
392
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
49793
392
    } while (0);
49794
49795
392
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49796
5
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
49797
5
    }
49798
392
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
49799
392
  } else {
49800
80
    if (EXPECTED(Z_ISREF_P(container))) {
49801
0
      container = Z_REFVAL_P(container);
49802
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49803
0
        goto assign_dim_op_array;
49804
0
      }
49805
0
    }
49806
49807
80
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
49808
5
      zend_object *obj = Z_OBJ_P(container);
49809
49810
5
      dim = NULL;
49811
5
      if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
49812
0
        dim++;
49813
0
      }
49814
5
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
49815
75
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
49816
68
      uint8_t old_type;
49817
49818
68
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
49819
31
        ZVAL_UNDEFINED_OP1();
49820
31
      }
49821
68
      ht = zend_new_array(8);
49822
68
      old_type = Z_TYPE_P(container);
49823
68
      ZVAL_ARR(container, ht);
49824
68
      if (UNEXPECTED(old_type == IS_FALSE)) {
49825
12
        GC_ADDREF(ht);
49826
12
        zend_false_to_array_deprecated();
49827
12
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
49828
0
          zend_array_destroy(ht);
49829
0
          goto assign_dim_op_ret_null;
49830
0
        }
49831
12
      }
49832
68
      goto assign_dim_op_new_array;
49833
68
    } else {
49834
7
      dim = NULL;
49835
7
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
49836
26
assign_dim_op_ret_null:
49837
26
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
49838
26
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49839
19
        ZVAL_NULL(EX_VAR(opline->result.var));
49840
19
      }
49841
26
    }
49842
80
  }
49843
49844
49845
423
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
49846
423
}
49847
49848
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)
49849
34.3k
{
49850
34.3k
  USE_OPLINE
49851
34.3k
  zval *varname;
49852
34.3k
  zval *retval;
49853
34.3k
  zend_string *name, *tmp_name;
49854
34.3k
  HashTable *target_symbol_table;
49855
49856
34.3k
  SAVE_OPLINE();
49857
34.3k
  varname = EX_VAR(opline->op1.var);
49858
49859
34.3k
  if (IS_CV == IS_CONST) {
49860
0
    name = Z_STR_P(varname);
49861
34.3k
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
49862
6.47k
    name = Z_STR_P(varname);
49863
6.47k
    tmp_name = NULL;
49864
27.8k
  } else {
49865
27.8k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
49866
13.6k
      ZVAL_UNDEFINED_OP1();
49867
13.6k
    }
49868
27.8k
    name = zval_try_get_tmp_string(varname, &tmp_name);
49869
27.8k
    if (UNEXPECTED(!name)) {
49870
266
      if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
49871
49872
266
      }
49873
266
      ZVAL_UNDEF(EX_VAR(opline->result.var));
49874
266
      HANDLE_EXCEPTION();
49875
266
    }
49876
27.8k
  }
49877
49878
34.0k
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
49879
34.0k
  retval = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
49880
34.0k
  if (retval == NULL) {
49881
20.1k
    if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
49882
18
fetch_this:
49883
18
      zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
49884
18
      if (IS_CV != IS_CONST) {
49885
18
        zend_tmp_string_release(tmp_name);
49886
18
      }
49887
18
      ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49888
18
    }
49889
20.0k
    if (type == BP_VAR_W) {
49890
9.07k
      retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
49891
11.0k
    } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
49892
12
      retval = &EG(uninitialized_zval);
49893
11.0k
    } else {
49894
11.0k
      if (IS_CV == IS_CV) {
49895
        /* Keep name alive in case an error handler tries to free it. */
49896
11.0k
        zend_string_addref(name);
49897
11.0k
      }
49898
11.0k
      zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
49899
11.0k
        (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
49900
11.0k
      if (type == BP_VAR_RW && !EG(exception)) {
49901
4.17k
        retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
49902
6.84k
      } else {
49903
6.84k
        retval = &EG(uninitialized_zval);
49904
6.84k
      }
49905
11.0k
      if (IS_CV == IS_CV) {
49906
11.0k
        zend_string_release(name);
49907
11.0k
      }
49908
11.0k
    }
49909
  /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
49910
20.0k
  } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
49911
172
    retval = Z_INDIRECT_P(retval);
49912
172
    if (Z_TYPE_P(retval) == IS_UNDEF) {
49913
12
      if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
49914
0
        goto fetch_this;
49915
0
      }
49916
12
      if (type == BP_VAR_W) {
49917
12
        ZVAL_NULL(retval);
49918
12
      } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
49919
0
        retval = &EG(uninitialized_zval);
49920
0
      } else {
49921
0
        zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
49922
0
          (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
49923
0
        if (type == BP_VAR_RW && !EG(exception)) {
49924
0
          ZVAL_NULL(retval);
49925
0
        } else {
49926
0
          retval = &EG(uninitialized_zval);
49927
0
        }
49928
0
      }
49929
12
    }
49930
172
  }
49931
49932
34.0k
  if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
49933
49934
34.0k
  }
49935
49936
34.0k
  if (IS_CV != IS_CONST) {
49937
34.0k
    zend_tmp_string_release(tmp_name);
49938
34.0k
  }
49939
49940
34.0k
  ZEND_ASSERT(retval != NULL);
49941
34.0k
  if (type == BP_VAR_R || type == BP_VAR_IS) {
49942
8.79k
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
49943
25.2k
  } else {
49944
25.2k
    ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
49945
25.2k
  }
49946
34.0k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49947
34.0k
}
49948
49949
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49950
8.17k
{
49951
8.17k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R));
49952
8.17k
}
49953
49954
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49955
15.0k
{
49956
15.0k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W));
49957
15.0k
}
49958
49959
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49960
10.4k
{
49961
10.4k
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW));
49962
10.4k
}
49963
49964
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49965
634
{
49966
634
  int fetch_type =
49967
634
    (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
49968
634
      BP_VAR_W : BP_VAR_R;
49969
634
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type));
49970
634
}
49971
49972
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49973
0
{
49974
0
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET));
49975
0
}
49976
49977
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49978
12
{
49979
12
  ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS));
49980
12
}
49981
49982
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
49983
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49984
2.24k
{
49985
2.24k
  USE_OPLINE
49986
2.24k
  zval *container;
49987
49988
2.24k
  SAVE_OPLINE();
49989
2.24k
  container = EX_VAR(opline->op1.var);
49990
2.24k
  zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
49991
49992
2.24k
  if (IS_CV == IS_VAR) {
49993
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
49994
0
  }
49995
2.24k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49996
2.24k
}
49997
49998
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49999
29
{
50000
29
  USE_OPLINE
50001
29
  zval *container;
50002
50003
29
  SAVE_OPLINE();
50004
29
  container = EX_VAR(opline->op1.var);
50005
29
  zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
50006
50007
29
  if (IS_CV == IS_VAR) {
50008
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
50009
0
  }
50010
29
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50011
29
}
50012
50013
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50014
10
{
50015
#if 0
50016
  USE_OPLINE
50017
#endif
50018
50019
10
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
50020
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
50021
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50022
0
    }
50023
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50024
10
  } else {
50025
10
    if (IS_UNUSED == IS_UNUSED) {
50026
10
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50027
10
    }
50028
10
    ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50029
10
  }
50030
10
}
50031
50032
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50033
4.78k
{
50034
4.78k
  USE_OPLINE
50035
4.78k
  zval *object_ptr, *orig_object_ptr;
50036
4.78k
  zval *value;
50037
4.78k
  zval *variable_ptr;
50038
4.78k
  zval *dim;
50039
4.78k
  zend_refcounted *garbage = NULL;
50040
50041
4.78k
  SAVE_OPLINE();
50042
4.78k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50043
50044
4.78k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50045
4.74k
try_assign_dim_array:
50046
4.74k
    SEPARATE_ARRAY(object_ptr);
50047
4.74k
    if (IS_UNUSED == IS_UNUSED) {
50048
4.74k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
50049
4.74k
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50050
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
50051
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50052
0
          GC_ADDREF(ht);
50053
0
        }
50054
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50055
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50056
0
          zend_array_destroy(ht);
50057
0
          goto assign_dim_error;
50058
0
        }
50059
0
      }
50060
4.74k
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
50061
0
        ZVAL_DEREF(value);
50062
0
      }
50063
4.74k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50064
4.74k
      if (UNEXPECTED(value == NULL)) {
50065
26
        zend_cannot_add_element();
50066
26
        goto assign_dim_error;
50067
4.71k
      } else if (IS_CONST == IS_CV) {
50068
0
        if (Z_REFCOUNTED_P(value)) {
50069
0
          Z_ADDREF_P(value);
50070
0
        }
50071
4.71k
      } else if (IS_CONST == IS_VAR) {
50072
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
50073
0
        if (Z_ISREF_P(free_op_data)) {
50074
0
          if (Z_REFCOUNTED_P(value)) {
50075
0
            Z_ADDREF_P(value);
50076
0
          }
50077
0
          zval_ptr_dtor_nogc(free_op_data);
50078
0
        }
50079
4.71k
      } else if (IS_CONST == IS_CONST) {
50080
4.71k
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50081
0
          Z_ADDREF_P(value);
50082
0
        }
50083
4.71k
      }
50084
4.74k
    } else {
50085
0
      dim = NULL;
50086
0
      if (IS_UNUSED == IS_CONST) {
50087
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50088
0
      } else {
50089
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50090
0
      }
50091
0
      if (UNEXPECTED(variable_ptr == NULL)) {
50092
0
        goto assign_dim_error;
50093
0
      }
50094
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
50095
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
50096
0
    }
50097
4.71k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50098
14
      ZVAL_COPY(EX_VAR(opline->result.var), value);
50099
14
    }
50100
4.71k
    if (garbage) {
50101
0
      GC_DTOR_NO_REF(garbage);
50102
0
    }
50103
4.71k
  } else {
50104
1.21k
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
50105
904
      object_ptr = Z_REFVAL_P(object_ptr);
50106
904
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50107
821
        goto try_assign_dim_array;
50108
821
      }
50109
904
    }
50110
397
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50111
15
      zend_object *obj = Z_OBJ_P(object_ptr);
50112
50113
15
      GC_ADDREF(obj);
50114
15
      dim = NULL;
50115
15
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50116
0
        dim = ZVAL_UNDEFINED_OP2();
50117
15
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50118
0
        dim++;
50119
0
      }
50120
50121
15
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
50122
15
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50123
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50124
15
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
50125
0
        ZVAL_DEREF(value);
50126
0
      }
50127
50128
15
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50129
50130
15
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50131
0
        zend_objects_store_del(obj);
50132
0
      }
50133
382
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50134
26
      if (IS_UNUSED == IS_UNUSED) {
50135
26
        zend_use_new_element_for_string();
50136
50137
26
        UNDEF_RESULT();
50138
26
      } else {
50139
0
        dim = NULL;
50140
0
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
50141
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50142
50143
0
      }
50144
356
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50145
356
      if (Z_ISREF_P(orig_object_ptr)
50146
356
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50147
356
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50148
7
        dim = NULL;
50149
50150
7
        UNDEF_RESULT();
50151
349
      } else {
50152
349
        HashTable *ht = zend_new_array(8);
50153
349
        uint8_t old_type = Z_TYPE_P(object_ptr);
50154
50155
349
        ZVAL_ARR(object_ptr, ht);
50156
349
        if (UNEXPECTED(old_type == IS_FALSE)) {
50157
228
          GC_ADDREF(ht);
50158
228
          zend_false_to_array_deprecated();
50159
228
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50160
0
            zend_array_destroy(ht);
50161
0
            goto assign_dim_error;
50162
0
          }
50163
228
        }
50164
349
        goto try_assign_dim_array;
50165
349
      }
50166
356
    } else {
50167
0
      zend_use_scalar_as_array();
50168
0
      dim = NULL;
50169
26
assign_dim_error:
50170
50171
26
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50172
5
        ZVAL_NULL(EX_VAR(opline->result.var));
50173
5
      }
50174
26
    }
50175
397
  }
50176
4.78k
  if (IS_UNUSED != IS_UNUSED) {
50177
50178
0
  }
50179
50180
  /* assign_dim has two opcodes! */
50181
4.78k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
50182
4.78k
}
50183
50184
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50185
1.35k
{
50186
1.35k
  USE_OPLINE
50187
1.35k
  zval *object_ptr, *orig_object_ptr;
50188
1.35k
  zval *value;
50189
1.35k
  zval *variable_ptr;
50190
1.35k
  zval *dim;
50191
1.35k
  zend_refcounted *garbage = NULL;
50192
50193
1.35k
  SAVE_OPLINE();
50194
1.35k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50195
50196
1.35k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50197
1.35k
try_assign_dim_array:
50198
1.35k
    SEPARATE_ARRAY(object_ptr);
50199
1.35k
    if (IS_UNUSED == IS_UNUSED) {
50200
1.35k
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50201
1.35k
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50202
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
50203
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50204
0
          GC_ADDREF(ht);
50205
0
        }
50206
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50207
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50208
0
          zend_array_destroy(ht);
50209
0
          goto assign_dim_error;
50210
0
        }
50211
0
      }
50212
1.35k
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
50213
0
        ZVAL_DEREF(value);
50214
0
      }
50215
1.35k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50216
1.35k
      if (UNEXPECTED(value == NULL)) {
50217
3
        zend_cannot_add_element();
50218
3
        goto assign_dim_error;
50219
1.35k
      } else if (IS_TMP_VAR == IS_CV) {
50220
0
        if (Z_REFCOUNTED_P(value)) {
50221
0
          Z_ADDREF_P(value);
50222
0
        }
50223
1.35k
      } else if (IS_TMP_VAR == IS_VAR) {
50224
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
50225
0
        if (Z_ISREF_P(free_op_data)) {
50226
0
          if (Z_REFCOUNTED_P(value)) {
50227
0
            Z_ADDREF_P(value);
50228
0
          }
50229
0
          zval_ptr_dtor_nogc(free_op_data);
50230
0
        }
50231
1.35k
      } else if (IS_TMP_VAR == IS_CONST) {
50232
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50233
0
          Z_ADDREF_P(value);
50234
0
        }
50235
0
      }
50236
1.35k
    } else {
50237
0
      dim = NULL;
50238
0
      if (IS_UNUSED == IS_CONST) {
50239
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50240
0
      } else {
50241
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50242
0
      }
50243
0
      if (UNEXPECTED(variable_ptr == NULL)) {
50244
0
        goto assign_dim_error;
50245
0
      }
50246
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50247
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
50248
0
    }
50249
1.35k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50250
40
      ZVAL_COPY(EX_VAR(opline->result.var), value);
50251
40
    }
50252
1.35k
    if (garbage) {
50253
0
      GC_DTOR_NO_REF(garbage);
50254
0
    }
50255
1.35k
  } else {
50256
95
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
50257
59
      object_ptr = Z_REFVAL_P(object_ptr);
50258
59
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50259
54
        goto try_assign_dim_array;
50260
54
      }
50261
59
    }
50262
41
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50263
0
      zend_object *obj = Z_OBJ_P(object_ptr);
50264
50265
0
      GC_ADDREF(obj);
50266
0
      dim = NULL;
50267
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50268
0
        dim = ZVAL_UNDEFINED_OP2();
50269
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50270
0
        dim++;
50271
0
      }
50272
50273
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50274
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50275
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50276
0
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
50277
0
        ZVAL_DEREF(value);
50278
0
      }
50279
50280
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50281
50282
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50283
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50284
0
        zend_objects_store_del(obj);
50285
0
      }
50286
41
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50287
0
      if (IS_UNUSED == IS_UNUSED) {
50288
0
        zend_use_new_element_for_string();
50289
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50290
0
        UNDEF_RESULT();
50291
0
      } else {
50292
0
        dim = NULL;
50293
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50294
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50295
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50296
0
      }
50297
41
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50298
41
      if (Z_ISREF_P(orig_object_ptr)
50299
41
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50300
41
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50301
0
        dim = NULL;
50302
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50303
0
        UNDEF_RESULT();
50304
41
      } else {
50305
41
        HashTable *ht = zend_new_array(8);
50306
41
        uint8_t old_type = Z_TYPE_P(object_ptr);
50307
50308
41
        ZVAL_ARR(object_ptr, ht);
50309
41
        if (UNEXPECTED(old_type == IS_FALSE)) {
50310
0
          GC_ADDREF(ht);
50311
0
          zend_false_to_array_deprecated();
50312
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50313
0
            zend_array_destroy(ht);
50314
0
            goto assign_dim_error;
50315
0
          }
50316
0
        }
50317
41
        goto try_assign_dim_array;
50318
41
      }
50319
41
    } else {
50320
0
      zend_use_scalar_as_array();
50321
0
      dim = NULL;
50322
3
assign_dim_error:
50323
3
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50324
3
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50325
3
        ZVAL_NULL(EX_VAR(opline->result.var));
50326
3
      }
50327
3
    }
50328
41
  }
50329
1.35k
  if (IS_UNUSED != IS_UNUSED) {
50330
50331
0
  }
50332
50333
  /* assign_dim has two opcodes! */
50334
1.35k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
50335
1.35k
}
50336
50337
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50338
2.53k
{
50339
2.53k
  USE_OPLINE
50340
2.53k
  zval *object_ptr, *orig_object_ptr;
50341
2.53k
  zval *value;
50342
2.53k
  zval *variable_ptr;
50343
2.53k
  zval *dim;
50344
2.53k
  zend_refcounted *garbage = NULL;
50345
50346
2.53k
  SAVE_OPLINE();
50347
2.53k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50348
50349
2.53k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50350
2.53k
try_assign_dim_array:
50351
2.53k
    SEPARATE_ARRAY(object_ptr);
50352
2.53k
    if (IS_UNUSED == IS_UNUSED) {
50353
2.53k
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50354
2.53k
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50355
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
50356
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50357
0
          GC_ADDREF(ht);
50358
0
        }
50359
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50360
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50361
0
          zend_array_destroy(ht);
50362
0
          goto assign_dim_error;
50363
0
        }
50364
0
      }
50365
2.53k
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
50366
2.53k
        ZVAL_DEREF(value);
50367
2.53k
      }
50368
2.53k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50369
2.53k
      if (UNEXPECTED(value == NULL)) {
50370
0
        zend_cannot_add_element();
50371
0
        goto assign_dim_error;
50372
2.53k
      } else if (IS_VAR == IS_CV) {
50373
0
        if (Z_REFCOUNTED_P(value)) {
50374
0
          Z_ADDREF_P(value);
50375
0
        }
50376
2.53k
      } else if (IS_VAR == IS_VAR) {
50377
2.53k
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
50378
2.53k
        if (Z_ISREF_P(free_op_data)) {
50379
15
          if (Z_REFCOUNTED_P(value)) {
50380
5
            Z_ADDREF_P(value);
50381
5
          }
50382
15
          zval_ptr_dtor_nogc(free_op_data);
50383
15
        }
50384
2.53k
      } else if (IS_VAR == IS_CONST) {
50385
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50386
0
          Z_ADDREF_P(value);
50387
0
        }
50388
0
      }
50389
2.53k
    } else {
50390
0
      dim = NULL;
50391
0
      if (IS_UNUSED == IS_CONST) {
50392
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50393
0
      } else {
50394
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50395
0
      }
50396
0
      if (UNEXPECTED(variable_ptr == NULL)) {
50397
0
        goto assign_dim_error;
50398
0
      }
50399
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50400
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
50401
0
    }
50402
2.53k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50403
14
      ZVAL_COPY(EX_VAR(opline->result.var), value);
50404
14
    }
50405
2.53k
    if (garbage) {
50406
0
      GC_DTOR_NO_REF(garbage);
50407
0
    }
50408
2.53k
  } else {
50409
637
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
50410
577
      object_ptr = Z_REFVAL_P(object_ptr);
50411
577
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50412
433
        goto try_assign_dim_array;
50413
433
      }
50414
577
    }
50415
204
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50416
0
      zend_object *obj = Z_OBJ_P(object_ptr);
50417
50418
0
      GC_ADDREF(obj);
50419
0
      dim = NULL;
50420
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50421
0
        dim = ZVAL_UNDEFINED_OP2();
50422
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50423
0
        dim++;
50424
0
      }
50425
50426
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50427
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50428
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50429
0
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
50430
0
        ZVAL_DEREF(value);
50431
0
      }
50432
50433
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50434
50435
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50436
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50437
0
        zend_objects_store_del(obj);
50438
0
      }
50439
204
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50440
0
      if (IS_UNUSED == IS_UNUSED) {
50441
0
        zend_use_new_element_for_string();
50442
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50443
0
        UNDEF_RESULT();
50444
0
      } else {
50445
0
        dim = NULL;
50446
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50447
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50448
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50449
0
      }
50450
204
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50451
204
      if (Z_ISREF_P(orig_object_ptr)
50452
204
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50453
204
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50454
0
        dim = NULL;
50455
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50456
0
        UNDEF_RESULT();
50457
204
      } else {
50458
204
        HashTable *ht = zend_new_array(8);
50459
204
        uint8_t old_type = Z_TYPE_P(object_ptr);
50460
50461
204
        ZVAL_ARR(object_ptr, ht);
50462
204
        if (UNEXPECTED(old_type == IS_FALSE)) {
50463
5
          GC_ADDREF(ht);
50464
5
          zend_false_to_array_deprecated();
50465
5
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50466
0
            zend_array_destroy(ht);
50467
0
            goto assign_dim_error;
50468
0
          }
50469
5
        }
50470
204
        goto try_assign_dim_array;
50471
204
      }
50472
204
    } else {
50473
0
      zend_use_scalar_as_array();
50474
0
      dim = NULL;
50475
0
assign_dim_error:
50476
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50477
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50478
0
        ZVAL_NULL(EX_VAR(opline->result.var));
50479
0
      }
50480
0
    }
50481
204
  }
50482
2.53k
  if (IS_UNUSED != IS_UNUSED) {
50483
50484
0
  }
50485
50486
  /* assign_dim has two opcodes! */
50487
2.53k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
50488
2.53k
}
50489
50490
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50491
5.29k
{
50492
5.29k
  USE_OPLINE
50493
5.29k
  zval *object_ptr, *orig_object_ptr;
50494
5.29k
  zval *value;
50495
5.29k
  zval *variable_ptr;
50496
5.29k
  zval *dim;
50497
5.29k
  zend_refcounted *garbage = NULL;
50498
50499
5.29k
  SAVE_OPLINE();
50500
5.29k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50501
50502
5.29k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50503
5.26k
try_assign_dim_array:
50504
5.26k
    SEPARATE_ARRAY(object_ptr);
50505
5.26k
    if (IS_UNUSED == IS_UNUSED) {
50506
5.26k
      value = EX_VAR((opline+1)->op1.var);
50507
5.26k
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50508
337
        HashTable *ht = Z_ARRVAL_P(object_ptr);
50509
337
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50510
337
          GC_ADDREF(ht);
50511
337
        }
50512
337
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50513
337
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50514
0
          zend_array_destroy(ht);
50515
0
          goto assign_dim_error;
50516
0
        }
50517
337
      }
50518
5.26k
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
50519
5.26k
        ZVAL_DEREF(value);
50520
5.26k
      }
50521
5.26k
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50522
5.26k
      if (UNEXPECTED(value == NULL)) {
50523
0
        zend_cannot_add_element();
50524
0
        goto assign_dim_error;
50525
5.26k
      } else if (IS_CV == IS_CV) {
50526
5.26k
        if (Z_REFCOUNTED_P(value)) {
50527
1.63k
          Z_ADDREF_P(value);
50528
1.63k
        }
50529
5.26k
      } else if (IS_CV == IS_VAR) {
50530
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
50531
0
        if (Z_ISREF_P(free_op_data)) {
50532
0
          if (Z_REFCOUNTED_P(value)) {
50533
0
            Z_ADDREF_P(value);
50534
0
          }
50535
0
          zval_ptr_dtor_nogc(free_op_data);
50536
0
        }
50537
0
      } else if (IS_CV == IS_CONST) {
50538
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50539
0
          Z_ADDREF_P(value);
50540
0
        }
50541
0
      }
50542
5.26k
    } else {
50543
0
      dim = NULL;
50544
0
      if (IS_UNUSED == IS_CONST) {
50545
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50546
0
      } else {
50547
0
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50548
0
      }
50549
0
      if (UNEXPECTED(variable_ptr == NULL)) {
50550
0
        goto assign_dim_error;
50551
0
      }
50552
0
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
50553
0
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
50554
0
    }
50555
5.26k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50556
2
      ZVAL_COPY(EX_VAR(opline->result.var), value);
50557
2
    }
50558
5.26k
    if (garbage) {
50559
0
      GC_DTOR_NO_REF(garbage);
50560
0
    }
50561
5.26k
  } else {
50562
239
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
50563
134
      object_ptr = Z_REFVAL_P(object_ptr);
50564
134
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50565
134
        goto try_assign_dim_array;
50566
134
      }
50567
134
    }
50568
105
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50569
0
      zend_object *obj = Z_OBJ_P(object_ptr);
50570
50571
0
      GC_ADDREF(obj);
50572
0
      dim = NULL;
50573
0
      if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50574
0
        dim = ZVAL_UNDEFINED_OP2();
50575
0
      } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50576
0
        dim++;
50577
0
      }
50578
50579
0
      value = EX_VAR((opline+1)->op1.var);
50580
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50581
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50582
0
      } else if (IS_CV & (IS_CV|IS_VAR)) {
50583
0
        ZVAL_DEREF(value);
50584
0
      }
50585
50586
0
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50587
50588
0
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50589
0
        zend_objects_store_del(obj);
50590
0
      }
50591
105
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50592
0
      if (IS_UNUSED == IS_UNUSED) {
50593
0
        zend_use_new_element_for_string();
50594
50595
0
        UNDEF_RESULT();
50596
0
      } else {
50597
0
        dim = NULL;
50598
0
        value = EX_VAR((opline+1)->op1.var);
50599
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50600
50601
0
      }
50602
105
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50603
78
      if (Z_ISREF_P(orig_object_ptr)
50604
78
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50605
78
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50606
0
        dim = NULL;
50607
50608
0
        UNDEF_RESULT();
50609
78
      } else {
50610
78
        HashTable *ht = zend_new_array(8);
50611
78
        uint8_t old_type = Z_TYPE_P(object_ptr);
50612
50613
78
        ZVAL_ARR(object_ptr, ht);
50614
78
        if (UNEXPECTED(old_type == IS_FALSE)) {
50615
5
          GC_ADDREF(ht);
50616
5
          zend_false_to_array_deprecated();
50617
5
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50618
0
            zend_array_destroy(ht);
50619
0
            goto assign_dim_error;
50620
0
          }
50621
5
        }
50622
78
        goto try_assign_dim_array;
50623
78
      }
50624
78
    } else {
50625
27
      zend_use_scalar_as_array();
50626
27
      dim = NULL;
50627
27
assign_dim_error:
50628
50629
27
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50630
0
        ZVAL_NULL(EX_VAR(opline->result.var));
50631
0
      }
50632
27
    }
50633
105
  }
50634
5.29k
  if (IS_UNUSED != IS_UNUSED) {
50635
50636
0
  }
50637
50638
  /* assign_dim has two opcodes! */
50639
5.29k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
50640
5.29k
}
50641
50642
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50643
644
{
50644
644
  if (IS_CV == IS_UNUSED) {
50645
0
    SAVE_OPLINE();
50646
0
    zend_verify_missing_return_type(EX(func));
50647
0
    HANDLE_EXCEPTION();
50648
644
  } else {
50649
/* prevents "undefined variable opline" errors */
50650
644
#if 0 || (IS_CV != IS_UNUSED)
50651
644
    USE_OPLINE
50652
644
    zval *retval_ref, *retval_ptr;
50653
644
    zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
50654
644
    retval_ref = retval_ptr = EX_VAR(opline->op1.var);
50655
50656
644
    if (IS_CV == IS_CONST) {
50657
0
      ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
50658
0
      retval_ref = retval_ptr = EX_VAR(opline->result.var);
50659
644
    } else if (IS_CV == IS_VAR) {
50660
0
      if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
50661
0
        retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
50662
0
      }
50663
0
      ZVAL_DEREF(retval_ptr);
50664
644
    } else if (IS_CV == IS_CV) {
50665
644
      ZVAL_DEREF(retval_ptr);
50666
644
    }
50667
50668
644
    if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
50669
276
      ZEND_VM_NEXT_OPCODE();
50670
276
    }
50671
50672
368
    if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
50673
31
      SAVE_OPLINE();
50674
31
      retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
50675
31
      if (UNEXPECTED(EG(exception))) {
50676
0
        HANDLE_EXCEPTION();
50677
0
      }
50678
31
      if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
50679
13
        ZEND_VM_NEXT_OPCODE();
50680
13
      }
50681
31
    }
50682
50683
355
    zend_reference *ref = NULL;
50684
355
    if (UNEXPECTED(retval_ref != retval_ptr)) {
50685
30
      if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
50686
15
        ref = Z_REF_P(retval_ref);
50687
15
      } else {
50688
        /* A cast might happen - unwrap the reference if this is a by-value return */
50689
15
        if (Z_REFCOUNT_P(retval_ref) == 1) {
50690
5
          ZVAL_UNREF(retval_ref);
50691
10
        } else {
50692
10
          Z_DELREF_P(retval_ref);
50693
10
          ZVAL_COPY(retval_ref, retval_ptr);
50694
10
        }
50695
15
        retval_ptr = retval_ref;
50696
15
      }
50697
30
    }
50698
50699
355
    SAVE_OPLINE();
50700
355
    if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, 1, 0))) {
50701
66
      zend_verify_return_error(EX(func), retval_ptr);
50702
66
      HANDLE_EXCEPTION();
50703
66
    }
50704
289
    ZEND_VM_NEXT_OPCODE();
50705
289
#endif
50706
289
  }
50707
644
}
50708
50709
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50710
34.7k
{
50711
34.7k
  USE_OPLINE
50712
34.7k
  zval *varptr, *arg;
50713
50714
34.7k
  if (IS_UNUSED == IS_CONST) {
50715
0
    SAVE_OPLINE();
50716
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50717
0
    uint32_t arg_num;
50718
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50719
0
    if (UNEXPECTED(!arg)) {
50720
50721
0
      HANDLE_EXCEPTION();
50722
0
    }
50723
34.7k
  } else {
50724
34.7k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50725
34.7k
  }
50726
50727
34.7k
  varptr = EX_VAR(opline->op1.var);
50728
34.7k
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50729
3.64k
    SAVE_OPLINE();
50730
3.64k
    ZVAL_UNDEFINED_OP1();
50731
3.64k
    ZVAL_NULL(arg);
50732
3.64k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50733
3.64k
  }
50734
50735
31.1k
  if (IS_CV == IS_CV) {
50736
31.1k
    ZVAL_COPY_DEREF(arg, varptr);
50737
31.1k
  } else /* if (IS_CV == IS_VAR) */ {
50738
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
50739
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
50740
50741
0
      varptr = Z_REFVAL_P(varptr);
50742
0
      ZVAL_COPY_VALUE(arg, varptr);
50743
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50744
0
        efree_size(ref, sizeof(zend_reference));
50745
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
50746
0
        Z_ADDREF_P(arg);
50747
0
      }
50748
0
    } else {
50749
0
      ZVAL_COPY_VALUE(arg, varptr);
50750
0
    }
50751
0
  }
50752
50753
31.1k
  ZEND_VM_NEXT_OPCODE();
50754
31.1k
}
50755
50756
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50757
4.72k
{
50758
4.72k
  USE_OPLINE
50759
4.72k
  zval *varptr, *arg;
50760
50761
4.72k
  SAVE_OPLINE();
50762
4.72k
  if (IS_UNUSED == IS_CONST) {
50763
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50764
0
    uint32_t arg_num;
50765
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50766
0
    if (UNEXPECTED(!arg)) {
50767
50768
0
      HANDLE_EXCEPTION();
50769
0
    }
50770
4.72k
  } else {
50771
4.72k
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50772
4.72k
  }
50773
50774
4.72k
  varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50775
4.72k
  if (Z_ISREF_P(varptr)) {
50776
3.10k
    Z_ADDREF_P(varptr);
50777
3.10k
  } else {
50778
1.61k
    ZVAL_MAKE_REF_EX(varptr, 2);
50779
1.61k
  }
50780
4.72k
  ZVAL_REF(arg, Z_REF_P(varptr));
50781
50782
4.72k
  ZEND_VM_NEXT_OPCODE();
50783
4.72k
}
50784
50785
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50786
5
{
50787
5
  USE_OPLINE
50788
5
  zval *varptr, *arg;
50789
5
  uint32_t arg_num;
50790
50791
5
  if (IS_UNUSED == IS_CONST) {
50792
0
    SAVE_OPLINE();
50793
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50794
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50795
0
    if (UNEXPECTED(!arg)) {
50796
50797
0
      HANDLE_EXCEPTION();
50798
0
    }
50799
5
  } else {
50800
5
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50801
5
    arg_num = opline->op2.num;
50802
5
  }
50803
50804
5
  if (EXPECTED(0)) {
50805
0
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50806
0
      goto send_var_by_ref;
50807
0
    }
50808
5
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50809
5
send_var_by_ref:
50810
5
    varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50811
5
    if (Z_ISREF_P(varptr)) {
50812
0
      Z_ADDREF_P(varptr);
50813
5
    } else {
50814
5
      ZVAL_MAKE_REF_EX(varptr, 2);
50815
5
    }
50816
5
    ZVAL_REF(arg, Z_REF_P(varptr));
50817
50818
5
    ZEND_VM_NEXT_OPCODE();
50819
5
  }
50820
50821
0
  varptr = EX_VAR(opline->op1.var);
50822
0
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50823
0
    SAVE_OPLINE();
50824
0
    ZVAL_UNDEFINED_OP1();
50825
0
    ZVAL_NULL(arg);
50826
0
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50827
0
  }
50828
50829
0
  if (IS_CV == IS_CV) {
50830
0
    ZVAL_COPY_DEREF(arg, varptr);
50831
0
  } else /* if (IS_CV == IS_VAR) */ {
50832
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
50833
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
50834
50835
0
      varptr = Z_REFVAL_P(varptr);
50836
0
      ZVAL_COPY_VALUE(arg, varptr);
50837
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50838
0
        efree_size(ref, sizeof(zend_reference));
50839
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
50840
0
        Z_ADDREF_P(arg);
50841
0
      }
50842
0
    } else {
50843
0
      ZVAL_COPY_VALUE(arg, varptr);
50844
0
    }
50845
0
  }
50846
50847
0
  ZEND_VM_NEXT_OPCODE();
50848
0
}
50849
50850
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50851
1.15M
{
50852
1.15M
  USE_OPLINE
50853
1.15M
  zval *varptr, *arg;
50854
1.15M
  uint32_t arg_num;
50855
50856
1.15M
  if (IS_UNUSED == IS_CONST) {
50857
0
    SAVE_OPLINE();
50858
0
    zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50859
0
    arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50860
0
    if (UNEXPECTED(!arg)) {
50861
50862
0
      HANDLE_EXCEPTION();
50863
0
    }
50864
1.15M
  } else {
50865
1.15M
    arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50866
1.15M
    arg_num = opline->op2.num;
50867
1.15M
  }
50868
50869
1.15M
  if (EXPECTED(1)) {
50870
1.15M
    if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50871
405
      goto send_var_by_ref;
50872
405
    }
50873
1.15M
  } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50874
405
send_var_by_ref:
50875
405
    varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50876
405
    if (Z_ISREF_P(varptr)) {
50877
229
      Z_ADDREF_P(varptr);
50878
229
    } else {
50879
176
      ZVAL_MAKE_REF_EX(varptr, 2);
50880
176
    }
50881
405
    ZVAL_REF(arg, Z_REF_P(varptr));
50882
50883
405
    ZEND_VM_NEXT_OPCODE();
50884
405
  }
50885
50886
1.15M
  varptr = EX_VAR(opline->op1.var);
50887
1.15M
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50888
548k
    SAVE_OPLINE();
50889
548k
    ZVAL_UNDEFINED_OP1();
50890
548k
    ZVAL_NULL(arg);
50891
548k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50892
548k
  }
50893
50894
607k
  if (IS_CV == IS_CV) {
50895
607k
    ZVAL_COPY_DEREF(arg, varptr);
50896
607k
  } else /* if (IS_CV == IS_VAR) */ {
50897
0
    if (UNEXPECTED(Z_ISREF_P(varptr))) {
50898
0
      zend_refcounted *ref = Z_COUNTED_P(varptr);
50899
50900
0
      varptr = Z_REFVAL_P(varptr);
50901
0
      ZVAL_COPY_VALUE(arg, varptr);
50902
0
      if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50903
0
        efree_size(ref, sizeof(zend_reference));
50904
0
      } else if (Z_OPT_REFCOUNTED_P(arg)) {
50905
0
        Z_ADDREF_P(arg);
50906
0
      }
50907
0
    } else {
50908
0
      ZVAL_COPY_VALUE(arg, varptr);
50909
0
    }
50910
0
  }
50911
50912
607k
  ZEND_VM_NEXT_OPCODE();
50913
607k
}
50914
50915
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50916
3.30k
{
50917
3.30k
  USE_OPLINE
50918
3.30k
  zval *expr_ptr, new_expr;
50919
50920
3.30k
  SAVE_OPLINE();
50921
3.30k
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
50922
3.30k
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
50923
345
    expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50924
345
    if (Z_ISREF_P(expr_ptr)) {
50925
126
      Z_ADDREF_P(expr_ptr);
50926
219
    } else {
50927
219
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
50928
219
    }
50929
50930
2.95k
  } else {
50931
2.95k
    expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50932
2.95k
    if (IS_CV == IS_TMP_VAR) {
50933
      /* pass */
50934
2.95k
    } else if (IS_CV == IS_CONST) {
50935
0
      Z_TRY_ADDREF_P(expr_ptr);
50936
2.95k
    } else if (IS_CV == IS_CV) {
50937
2.95k
      ZVAL_DEREF(expr_ptr);
50938
2.95k
      Z_TRY_ADDREF_P(expr_ptr);
50939
2.95k
    } else /* if (IS_CV == IS_VAR) */ {
50940
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
50941
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
50942
50943
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
50944
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50945
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
50946
0
          expr_ptr = &new_expr;
50947
0
          efree_size(ref, sizeof(zend_reference));
50948
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
50949
0
          Z_ADDREF_P(expr_ptr);
50950
0
        }
50951
0
      }
50952
0
    }
50953
2.95k
  }
50954
50955
3.30k
  if (IS_UNUSED != IS_UNUSED) {
50956
0
    zval *offset = NULL;
50957
0
    zend_string *str;
50958
0
    zend_ulong hval;
50959
50960
0
add_again:
50961
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
50962
0
      str = Z_STR_P(offset);
50963
0
      if (IS_UNUSED != IS_CONST) {
50964
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
50965
0
          goto num_index;
50966
0
        }
50967
0
      }
50968
0
str_index:
50969
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
50970
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
50971
0
      hval = Z_LVAL_P(offset);
50972
0
num_index:
50973
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
50974
0
    } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
50975
0
      offset = Z_REFVAL_P(offset);
50976
0
      goto add_again;
50977
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
50978
0
      str = ZSTR_EMPTY_ALLOC();
50979
0
      goto str_index;
50980
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
50981
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
50982
0
      goto num_index;
50983
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
50984
0
      hval = 0;
50985
0
      goto num_index;
50986
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
50987
0
      hval = 1;
50988
0
      goto num_index;
50989
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
50990
0
      zend_use_resource_as_offset(offset);
50991
0
      hval = Z_RES_HANDLE_P(offset);
50992
0
      goto num_index;
50993
0
    } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
50994
0
      ZVAL_UNDEFINED_OP2();
50995
0
      str = ZSTR_EMPTY_ALLOC();
50996
0
      goto str_index;
50997
0
    } else {
50998
0
      zend_illegal_array_offset_access(offset);
50999
0
      zval_ptr_dtor_nogc(expr_ptr);
51000
0
    }
51001
51002
3.30k
  } else {
51003
3.30k
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
51004
0
      zend_cannot_add_element();
51005
0
      zval_ptr_dtor_nogc(expr_ptr);
51006
0
    }
51007
3.30k
  }
51008
3.30k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51009
3.30k
}
51010
51011
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51012
2.41k
{
51013
2.41k
  zval *array;
51014
2.41k
  uint32_t size;
51015
2.41k
  USE_OPLINE
51016
51017
2.41k
  SAVE_OPLINE();
51018
2.41k
  array = EX_VAR(opline->result.var);
51019
2.41k
  if (IS_CV != IS_UNUSED) {
51020
2.41k
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
51021
2.41k
    ZVAL_ARR(array, zend_new_array(size));
51022
    /* Explicitly initialize array as not-packed if flag is set */
51023
2.41k
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
51024
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
51025
0
    }
51026
2.41k
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51027
2.41k
  } else {
51028
0
    ZVAL_ARR(array, zend_new_array(0));
51029
0
    ZEND_VM_NEXT_OPCODE();
51030
0
  }
51031
2.41k
}
51032
51033
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51034
6.98k
{
51035
6.98k
  USE_OPLINE
51036
6.98k
  zval *var = EX_VAR(opline->op1.var);
51037
51038
6.98k
  if (Z_REFCOUNTED_P(var)) {
51039
4.74k
    zend_refcounted *garbage = Z_COUNTED_P(var);
51040
51041
4.74k
    ZVAL_UNDEF(var);
51042
4.74k
    SAVE_OPLINE();
51043
4.74k
    GC_DTOR(garbage);
51044
4.74k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51045
4.74k
  } else {
51046
2.24k
    ZVAL_UNDEF(var);
51047
2.24k
  }
51048
2.24k
  ZEND_VM_NEXT_OPCODE();
51049
2.24k
}
51050
51051
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51052
136
{
51053
136
  USE_OPLINE
51054
136
  zval *varname;
51055
136
  zend_string *name, *tmp_name;
51056
136
  HashTable *target_symbol_table;
51057
51058
136
  SAVE_OPLINE();
51059
51060
136
  varname = EX_VAR(opline->op1.var);
51061
51062
136
  if (IS_CV == IS_CONST) {
51063
0
    name = Z_STR_P(varname);
51064
136
  } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
51065
60
    name = Z_STR_P(varname);
51066
60
    tmp_name = NULL;
51067
76
  } else {
51068
76
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
51069
61
      varname = ZVAL_UNDEFINED_OP1();
51070
61
    }
51071
76
    name = zval_try_get_tmp_string(varname, &tmp_name);
51072
76
    if (UNEXPECTED(!name)) {
51073
51074
10
      HANDLE_EXCEPTION();
51075
10
    }
51076
76
  }
51077
51078
126
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
51079
126
  zend_hash_del_ind(target_symbol_table, name);
51080
51081
126
  if (IS_CV != IS_CONST) {
51082
126
    zend_tmp_string_release(tmp_name);
51083
126
  }
51084
51085
126
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51086
126
}
51087
51088
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
51089
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51090
753
{
51091
753
  USE_OPLINE
51092
753
  zval *value;
51093
51094
753
  value = EX_VAR(opline->op1.var);
51095
753
  if (!(0)) {
51096
753
    if (Z_TYPE_P(value) > IS_NULL &&
51097
753
        (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
51098
49
      ZEND_VM_SMART_BRANCH_TRUE();
51099
704
    } else {
51100
704
      ZEND_VM_SMART_BRANCH_FALSE();
51101
704
    }
51102
753
  } else {
51103
0
    bool result;
51104
51105
0
    SAVE_OPLINE();
51106
0
    result = !i_zend_is_true(value);
51107
0
    ZEND_VM_SMART_BRANCH(result, 1);
51108
0
  }
51109
753
}
51110
51111
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51112
3
{
51113
3
  USE_OPLINE
51114
3
  zval *value;
51115
51116
3
  value = EX_VAR(opline->op1.var);
51117
3
  if (!(1)) {
51118
0
    if (Z_TYPE_P(value) > IS_NULL &&
51119
0
        (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
51120
0
      ZEND_VM_SMART_BRANCH_TRUE();
51121
0
    } else {
51122
0
      ZEND_VM_SMART_BRANCH_FALSE();
51123
0
    }
51124
3
  } else {
51125
3
    bool result;
51126
51127
3
    SAVE_OPLINE();
51128
3
    result = !i_zend_is_true(value);
51129
3
    ZEND_VM_SMART_BRANCH(result, 1);
51130
3
  }
51131
3
}
51132
51133
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51134
69
{
51135
69
  USE_OPLINE
51136
69
  zval *value;
51137
69
  bool result;
51138
69
  zval *varname;
51139
69
  zend_string *name, *tmp_name;
51140
69
  HashTable *target_symbol_table;
51141
51142
69
  SAVE_OPLINE();
51143
69
  varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
51144
69
  if (IS_CV == IS_CONST) {
51145
0
    name = Z_STR_P(varname);
51146
69
  } else {
51147
69
    name = zval_get_tmp_string(varname, &tmp_name);
51148
69
  }
51149
51150
69
  target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
51151
69
  value = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
51152
51153
69
  if (IS_CV != IS_CONST) {
51154
69
    zend_tmp_string_release(tmp_name);
51155
69
  }
51156
51157
69
  if (!value) {
51158
15
    result = (opline->extended_value & ZEND_ISEMPTY);
51159
54
  } else {
51160
54
    if (Z_TYPE_P(value) == IS_INDIRECT) {
51161
31
      value = Z_INDIRECT_P(value);
51162
31
    }
51163
54
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
51164
54
      if (Z_ISREF_P(value)) {
51165
0
        value = Z_REFVAL_P(value);
51166
0
      }
51167
54
      result = Z_TYPE_P(value) > IS_NULL;
51168
54
    } else {
51169
0
      result = !i_zend_is_true(value);
51170
0
    }
51171
54
  }
51172
51173
69
  ZEND_VM_SMART_BRANCH(result, true);
51174
69
}
51175
51176
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
51177
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51178
103
{
51179
103
  USE_OPLINE
51180
103
  zval *expr;
51181
103
  bool result;
51182
51183
103
  SAVE_OPLINE();
51184
103
  expr = EX_VAR(opline->op1.var);
51185
51186
103
try_instanceof:
51187
103
  if (Z_TYPE_P(expr) == IS_OBJECT) {
51188
101
    zend_class_entry *ce;
51189
51190
101
    if (IS_UNUSED == IS_CONST) {
51191
0
      ce = CACHED_PTR(opline->extended_value);
51192
0
      if (UNEXPECTED(ce == NULL)) {
51193
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);
51194
0
        if (EXPECTED(ce)) {
51195
0
          CACHE_PTR(opline->extended_value, ce);
51196
0
        }
51197
0
      }
51198
101
    } else if (IS_UNUSED == IS_UNUSED) {
51199
101
      ce = zend_fetch_class(NULL, opline->op2.num);
51200
101
      if (UNEXPECTED(ce == NULL)) {
51201
51202
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
51203
0
        HANDLE_EXCEPTION();
51204
0
      }
51205
101
    } else {
51206
0
      ce = Z_CE_P(EX_VAR(opline->op2.var));
51207
0
    }
51208
101
    result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
51209
101
  } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
51210
0
    expr = Z_REFVAL_P(expr);
51211
0
    goto try_instanceof;
51212
2
  } else {
51213
2
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
51214
2
      ZVAL_UNDEFINED_OP1();
51215
2
    }
51216
2
    result = 0;
51217
2
  }
51218
51219
103
  ZEND_VM_SMART_BRANCH(result, 1);
51220
103
}
51221
51222
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51223
1.20k
{
51224
1.20k
  USE_OPLINE
51225
51226
1.20k
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
51227
51228
1.20k
  SAVE_OPLINE();
51229
1.20k
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
51230
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51231
0
  }
51232
51233
  /* Destroy the previously yielded value */
51234
1.20k
  zval_ptr_dtor(&generator->value);
51235
51236
  /* Destroy the previously yielded key */
51237
1.20k
  zval_ptr_dtor(&generator->key);
51238
51239
  /* Set the new yielded value */
51240
1.20k
  if (IS_CV != IS_UNUSED) {
51241
1.20k
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
51242
      /* Constants and temporary variables aren't yieldable by reference,
51243
       * but we still allow them with a notice. */
51244
45
      if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
51245
0
        zval *value;
51246
51247
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
51248
51249
0
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51250
0
        ZVAL_COPY_VALUE(&generator->value, value);
51251
0
        if (IS_CV == IS_CONST) {
51252
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
51253
0
            Z_ADDREF(generator->value);
51254
0
          }
51255
0
        }
51256
45
      } else {
51257
45
        zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
51258
51259
        /* If a function call result is yielded and the function did
51260
         * not return by reference we throw a notice. */
51261
45
        do {
51262
45
          if (IS_CV == IS_VAR) {
51263
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
51264
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
51265
0
             && !Z_ISREF_P(value_ptr)) {
51266
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
51267
0
              ZVAL_COPY(&generator->value, value_ptr);
51268
0
              break;
51269
0
            }
51270
0
          }
51271
45
          if (Z_ISREF_P(value_ptr)) {
51272
15
            Z_ADDREF_P(value_ptr);
51273
30
          } else {
51274
30
            ZVAL_MAKE_REF_EX(value_ptr, 2);
51275
30
          }
51276
45
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
51277
45
        } while (0);
51278
51279
45
      }
51280
1.16k
    } else {
51281
1.16k
      zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51282
51283
      /* Consts, temporary variables and references need copying */
51284
1.16k
      if (IS_CV == IS_CONST) {
51285
0
        ZVAL_COPY_VALUE(&generator->value, value);
51286
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
51287
0
          Z_ADDREF(generator->value);
51288
0
        }
51289
1.16k
      } else if (IS_CV == IS_TMP_VAR) {
51290
0
        ZVAL_COPY_VALUE(&generator->value, value);
51291
1.16k
      } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
51292
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
51293
51294
1.16k
      } else {
51295
1.16k
        ZVAL_COPY_VALUE(&generator->value, value);
51296
1.16k
        if (IS_CV == IS_CV) {
51297
1.16k
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
51298
1.16k
        }
51299
1.16k
      }
51300
1.16k
    }
51301
1.20k
  } else {
51302
    /* If no value was specified yield null */
51303
0
    ZVAL_NULL(&generator->value);
51304
0
  }
51305
51306
  /* Set the new yielded key */
51307
1.20k
  if (IS_UNUSED != IS_UNUSED) {
51308
0
    zval *key = NULL;
51309
0
    if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
51310
0
      key = Z_REFVAL_P(key);
51311
0
    }
51312
0
    ZVAL_COPY(&generator->key, key);
51313
51314
0
    if (Z_TYPE(generator->key) == IS_LONG
51315
0
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
51316
0
    ) {
51317
0
      generator->largest_used_integer_key = Z_LVAL(generator->key);
51318
0
    }
51319
1.20k
  } else {
51320
    /* If no key was specified we use auto-increment keys */
51321
1.20k
    generator->largest_used_integer_key++;
51322
1.20k
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
51323
1.20k
  }
51324
51325
1.20k
  if (RETURN_VALUE_USED(opline)) {
51326
    /* If the return value of yield is used set the send
51327
     * target and initialize it to NULL */
51328
0
    generator->send_target = EX_VAR(opline->result.var);
51329
0
    ZVAL_NULL(generator->send_target);
51330
1.20k
  } else {
51331
1.20k
    generator->send_target = NULL;
51332
1.20k
  }
51333
51334
  /* The GOTO VM uses a local opline variable. We need to set the opline
51335
   * variable in execute_data so we don't resume at an old position. */
51336
1.20k
  SAVE_OPLINE();
51337
51338
1.20k
  ZEND_VM_RETURN();
51339
1.20k
}
51340
51341
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51342
15
{
51343
15
  USE_OPLINE
51344
15
  zval *op1 = EX_VAR(opline->op1.var);
51345
51346
15
  if (UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
51347
11
    SAVE_OPLINE();
51348
11
    ZVAL_UNDEFINED_OP1();
51349
11
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51350
11
  }
51351
4
  ZEND_VM_NEXT_OPCODE();
51352
4
}
51353
51354
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51355
240
{
51356
240
  USE_OPLINE
51357
240
  zval *op1 = EX_VAR(opline->op1.var);
51358
51359
240
  if (IS_CV == IS_CV) {
51360
240
    if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51361
17
      ZVAL_NEW_EMPTY_REF(op1);
51362
17
      Z_SET_REFCOUNT_P(op1, 2);
51363
17
      ZVAL_NULL(Z_REFVAL_P(op1));
51364
17
      ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51365
223
    } else {
51366
223
      if (Z_ISREF_P(op1)) {
51367
166
        Z_ADDREF_P(op1);
51368
166
      } else {
51369
57
        ZVAL_MAKE_REF_EX(op1, 2);
51370
57
      }
51371
223
      ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51372
223
    }
51373
240
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
51374
0
    op1 = Z_INDIRECT_P(op1);
51375
0
    if (EXPECTED(!Z_ISREF_P(op1))) {
51376
0
      ZVAL_MAKE_REF_EX(op1, 2);
51377
0
    } else {
51378
0
      GC_ADDREF(Z_REF_P(op1));
51379
0
    }
51380
0
    ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51381
0
  } else {
51382
0
    ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
51383
0
  }
51384
240
  ZEND_VM_NEXT_OPCODE();
51385
240
}
51386
51387
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51388
980
{
51389
980
  USE_OPLINE
51390
980
  zval *op1;
51391
980
  zend_long count;
51392
51393
980
  SAVE_OPLINE();
51394
980
  op1 = EX_VAR(opline->op1.var);
51395
51396
1.42k
  while (1) {
51397
1.42k
    if (Z_TYPE_P(op1) == IS_ARRAY) {
51398
900
      count = zend_hash_num_elements(Z_ARRVAL_P(op1));
51399
900
      break;
51400
900
    } else if (Z_TYPE_P(op1) == IS_OBJECT) {
51401
73
      zend_object *zobj = Z_OBJ_P(op1);
51402
51403
      /* first, we check if the handler is defined */
51404
73
      if (zobj->handlers->count_elements) {
51405
68
        if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
51406
68
          break;
51407
68
        }
51408
0
        if (UNEXPECTED(EG(exception))) {
51409
0
          count = 0;
51410
0
          break;
51411
0
        }
51412
0
      }
51413
51414
      /* if not and the object implements Countable we call its count() method */
51415
5
      if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
51416
0
        zval retval;
51417
51418
0
        zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
51419
0
        zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
51420
0
        count = zval_get_long(&retval);
51421
0
        zval_ptr_dtor(&retval);
51422
0
        break;
51423
0
      }
51424
51425
      /* If There's no handler and it doesn't implement Countable then emit a TypeError */
51426
448
    } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
51427
441
      op1 = Z_REFVAL_P(op1);
51428
441
      continue;
51429
441
    } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51430
5
      ZVAL_UNDEFINED_OP1();
51431
5
    }
51432
12
    count = 0;
51433
12
    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));
51434
12
    break;
51435
1.42k
  }
51436
51437
980
  ZVAL_LONG(EX_VAR(opline->result.var), count);
51438
51439
980
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51440
980
}
51441
51442
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51443
908
{
51444
908
  USE_OPLINE
51445
908
  zend_array *ht = Z_ARRVAL_P(EX_VAR(opline->op1.var));
51446
908
  ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
51447
908
  if (IS_CV & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
51448
0
    SAVE_OPLINE();
51449
0
    zend_array_destroy(ht);
51450
0
    if (EG(exception)) {
51451
0
      HANDLE_EXCEPTION();
51452
0
    }
51453
0
  }
51454
908
  ZEND_VM_NEXT_OPCODE();
51455
908
}
51456
51457
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51458
717
{
51459
717
  USE_OPLINE
51460
51461
717
  if (IS_CV == IS_UNUSED) {
51462
0
    SAVE_OPLINE();
51463
0
    if (UNEXPECTED(!EX(func)->common.scope)) {
51464
0
      zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
51465
0
      ZVAL_UNDEF(EX_VAR(opline->result.var));
51466
0
      HANDLE_EXCEPTION();
51467
0
    } else {
51468
0
      zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
51469
0
      ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
51470
0
      if (UNEXPECTED(EG(exception))) {
51471
0
        HANDLE_EXCEPTION();
51472
0
      }
51473
0
      ZEND_VM_NEXT_OPCODE();
51474
0
    }
51475
717
  } else {
51476
717
    zval *op1;
51477
51478
717
    SAVE_OPLINE();
51479
717
    op1 = EX_VAR(opline->op1.var);
51480
717
    while (1) {
51481
717
      if (Z_TYPE_P(op1) == IS_OBJECT) {
51482
707
        ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
51483
707
      } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
51484
0
        op1 = Z_REFVAL_P(op1);
51485
0
        continue;
51486
10
      } else {
51487
10
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51488
7
          ZVAL_UNDEFINED_OP1();
51489
7
        }
51490
10
        zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
51491
10
        ZVAL_UNDEF(EX_VAR(opline->result.var));
51492
10
      }
51493
717
      break;
51494
717
    }
51495
51496
717
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51497
717
  }
51498
717
}
51499
51500
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51501
14
{
51502
14
  USE_OPLINE
51503
14
  zval *op1;
51504
14
  zend_string *type;
51505
51506
14
  SAVE_OPLINE();
51507
14
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51508
14
  type = zend_zval_get_legacy_type(op1);
51509
14
  if (EXPECTED(type)) {
51510
14
    ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
51511
14
  } else {
51512
0
    ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
51513
0
  }
51514
51515
14
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51516
14
}
51517
51518
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51519
2.05k
{
51520
2.05k
  USE_OPLINE
51521
2.05k
  zval *varptr, *arg;
51522
2.05k
  uint32_t arg_num = opline->op2.num;
51523
51524
2.05k
  if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
51525
13
    ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51526
13
  }
51527
51528
2.04k
  varptr = EX_VAR(opline->op1.var);
51529
2.04k
  arg = ZEND_CALL_VAR(EX(call), opline->result.var);
51530
51531
2.04k
  if (IS_CV == IS_CV) {
51532
2.04k
    ZVAL_COPY(arg, varptr);
51533
2.04k
  } else /* if (IS_CV == IS_VAR) */ {
51534
0
    ZVAL_COPY_VALUE(arg, varptr);
51535
0
  }
51536
51537
2.04k
  ZEND_VM_NEXT_OPCODE();
51538
2.04k
}
51539
51540
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51541
220
{
51542
220
  USE_OPLINE
51543
220
  zval *op1, *op2;
51544
51545
220
  SAVE_OPLINE();
51546
220
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51547
220
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51548
220
  div_function(EX_VAR(opline->result.var), op1, op2);
51549
51550
51551
220
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51552
220
}
51553
51554
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51555
2
{
51556
2
  USE_OPLINE
51557
2
  zval *op1, *op2;
51558
51559
2
  SAVE_OPLINE();
51560
2
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51561
2
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51562
2
  pow_function(EX_VAR(opline->result.var), op1, op2);
51563
51564
51565
2
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51566
2
}
51567
51568
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51569
3.10k
{
51570
3.10k
  USE_OPLINE
51571
3.10k
  zval *op1, *op2;
51572
51573
3.10k
  op1 = EX_VAR(opline->op1.var);
51574
3.10k
  op2 = EX_VAR(opline->op2.var);
51575
51576
3.10k
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
51577
3.10k
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
51578
1.38k
    zend_string *op1_str = Z_STR_P(op1);
51579
1.38k
    zend_string *op2_str = Z_STR_P(op2);
51580
1.38k
    zend_string *str;
51581
1.38k
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
51582
51583
1.38k
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
51584
36
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
51585
36
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
51586
36
      } else {
51587
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
51588
0
      }
51589
36
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51590
0
        zend_string_release_ex(op1_str, 0);
51591
0
      }
51592
1.35k
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
51593
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
51594
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
51595
0
      } else {
51596
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
51597
0
      }
51598
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51599
0
        zend_string_release_ex(op2_str, 0);
51600
0
      }
51601
1.35k
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
51602
1.35k
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
51603
0
      size_t len = ZSTR_LEN(op1_str);
51604
51605
0
      if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
51606
0
        zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
51607
0
      }
51608
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
51609
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
51610
0
      GC_ADD_FLAGS(str, flags);
51611
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
51612
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51613
0
        zend_string_release_ex(op2_str, 0);
51614
0
      }
51615
1.35k
    } else {
51616
1.35k
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
51617
1.35k
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
51618
1.35k
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
51619
1.35k
      GC_ADD_FLAGS(str, flags);
51620
1.35k
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
51621
1.35k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51622
0
        zend_string_release_ex(op1_str, 0);
51623
0
      }
51624
1.35k
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51625
0
        zend_string_release_ex(op2_str, 0);
51626
0
      }
51627
1.35k
    }
51628
1.38k
    ZEND_VM_NEXT_OPCODE();
51629
1.72k
  } else {
51630
1.72k
    SAVE_OPLINE();
51631
51632
1.72k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51633
560
      op1 = ZVAL_UNDEFINED_OP1();
51634
560
    }
51635
1.72k
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
51636
1.17k
      op2 = ZVAL_UNDEFINED_OP2();
51637
1.17k
    }
51638
1.72k
    concat_function(EX_VAR(opline->result.var), op1, op2);
51639
51640
51641
1.72k
    ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51642
1.72k
  }
51643
3.10k
}
51644
51645
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51646
379
{
51647
379
  USE_OPLINE
51648
379
  zval *op1, *op2;
51649
379
  bool result;
51650
51651
379
  SAVE_OPLINE();
51652
379
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51653
379
  op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51654
379
  result = fast_is_identical_function(op1, op2);
51655
51656
51657
379
  ZEND_VM_SMART_BRANCH(result, 1);
51658
379
}
51659
51660
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51661
908
{
51662
908
  USE_OPLINE
51663
908
  zval *op1, *op2;
51664
908
  bool result;
51665
51666
908
  SAVE_OPLINE();
51667
908
  op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51668
908
  op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51669
908
  result = fast_is_not_identical_function(op1, op2);
51670
51671
51672
908
  ZEND_VM_SMART_BRANCH(result, 1);
51673
908
}
51674
51675
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51676
2.78k
{
51677
2.78k
  USE_OPLINE
51678
2.78k
  zval *op1, *op2;
51679
2.78k
  double d1, d2;
51680
51681
2.78k
  op1 = EX_VAR(opline->op1.var);
51682
2.78k
  op2 = EX_VAR(opline->op2.var);
51683
2.78k
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51684
    /* pass */
51685
2.78k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51686
1.70k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51687
1.00k
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51688
495
is_equal_true:
51689
495
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
51690
597
      } else {
51691
957
is_equal_false:
51692
957
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
51693
957
      }
51694
1.00k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51695
139
      d1 = (double)Z_LVAL_P(op1);
51696
139
      d2 = Z_DVAL_P(op2);
51697
139
      goto is_equal_double;
51698
139
    }
51699
1.70k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51700
332
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51701
203
      d1 = Z_DVAL_P(op1);
51702
203
      d2 = Z_DVAL_P(op2);
51703
347
is_equal_double:
51704
347
      if (d1 == d2) {
51705
10
        goto is_equal_true;
51706
337
      } else {
51707
337
        goto is_equal_false;
51708
337
      }
51709
347
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51710
5
      d1 = Z_DVAL_P(op1);
51711
5
      d2 = (double)Z_LVAL_P(op2);
51712
5
      goto is_equal_double;
51713
5
    }
51714
752
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51715
96
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51716
96
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51717
96
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51718
0
        zval_ptr_dtor_str(op1);
51719
0
      }
51720
96
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51721
0
        zval_ptr_dtor_str(op2);
51722
0
      }
51723
96
      if (result) {
51724
73
        goto is_equal_true;
51725
73
      } else {
51726
23
        goto is_equal_false;
51727
23
      }
51728
96
    }
51729
96
  }
51730
2.78k
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51731
2.78k
}
51732
51733
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51734
56
{
51735
56
  USE_OPLINE
51736
56
  zval *op1, *op2;
51737
56
  double d1, d2;
51738
51739
56
  op1 = EX_VAR(opline->op1.var);
51740
56
  op2 = EX_VAR(opline->op2.var);
51741
56
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51742
    /* pass */
51743
56
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51744
11
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51745
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51746
10
is_equal_true:
51747
10
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
51748
10
      } else {
51749
44
is_equal_false:
51750
44
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
51751
44
      }
51752
11
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51753
11
      d1 = (double)Z_LVAL_P(op1);
51754
11
      d2 = Z_DVAL_P(op2);
51755
11
      goto is_equal_double;
51756
11
    }
51757
45
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51758
23
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51759
23
      d1 = Z_DVAL_P(op1);
51760
23
      d2 = Z_DVAL_P(op2);
51761
34
is_equal_double:
51762
34
      if (d1 == d2) {
51763
0
        goto is_equal_true;
51764
34
      } else {
51765
34
        goto is_equal_false;
51766
34
      }
51767
34
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51768
0
      d1 = Z_DVAL_P(op1);
51769
0
      d2 = (double)Z_LVAL_P(op2);
51770
0
      goto is_equal_double;
51771
0
    }
51772
23
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51773
22
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51774
20
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51775
20
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51776
0
        zval_ptr_dtor_str(op1);
51777
0
      }
51778
20
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51779
0
        zval_ptr_dtor_str(op2);
51780
0
      }
51781
20
      if (result) {
51782
10
        goto is_equal_true;
51783
10
      } else {
51784
10
        goto is_equal_false;
51785
10
      }
51786
20
    }
51787
22
  }
51788
56
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51789
56
}
51790
51791
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51792
80
{
51793
80
  USE_OPLINE
51794
80
  zval *op1, *op2;
51795
80
  double d1, d2;
51796
51797
80
  op1 = EX_VAR(opline->op1.var);
51798
80
  op2 = EX_VAR(opline->op2.var);
51799
80
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51800
    /* pass */
51801
80
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51802
45
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51803
0
      if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51804
0
is_equal_true:
51805
0
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
51806
0
      } else {
51807
22
is_equal_false:
51808
22
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
51809
22
      }
51810
45
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51811
9
      d1 = (double)Z_LVAL_P(op1);
51812
9
      d2 = Z_DVAL_P(op2);
51813
9
      goto is_equal_double;
51814
9
    }
51815
45
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51816
13
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51817
13
      d1 = Z_DVAL_P(op1);
51818
13
      d2 = Z_DVAL_P(op2);
51819
22
is_equal_double:
51820
22
      if (d1 == d2) {
51821
0
        goto is_equal_true;
51822
22
      } else {
51823
22
        goto is_equal_false;
51824
22
      }
51825
22
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51826
0
      d1 = Z_DVAL_P(op1);
51827
0
      d2 = (double)Z_LVAL_P(op2);
51828
0
      goto is_equal_double;
51829
0
    }
51830
22
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51831
0
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51832
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51833
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51834
0
        zval_ptr_dtor_str(op1);
51835
0
      }
51836
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51837
0
        zval_ptr_dtor_str(op2);
51838
0
      }
51839
0
      if (result) {
51840
0
        goto is_equal_true;
51841
0
      } else {
51842
0
        goto is_equal_false;
51843
0
      }
51844
0
    }
51845
0
  }
51846
80
  ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51847
80
}
51848
51849
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51850
3.90k
{
51851
3.90k
  USE_OPLINE
51852
3.90k
  zval *op1, *op2;
51853
3.90k
  double d1, d2;
51854
51855
3.90k
  op1 = EX_VAR(opline->op1.var);
51856
3.90k
  op2 = EX_VAR(opline->op2.var);
51857
3.90k
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51858
    /* pass */
51859
3.90k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51860
490
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51861
102
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51862
127
is_not_equal_true:
51863
127
        ZEND_VM_SMART_BRANCH_TRUE_NONE();
51864
127
      } else {
51865
171
is_not_equal_false:
51866
171
        ZEND_VM_SMART_BRANCH_FALSE_NONE();
51867
171
      }
51868
388
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51869
12
      d1 = (double)Z_LVAL_P(op1);
51870
12
      d2 = Z_DVAL_P(op2);
51871
12
      goto is_not_equal_double;
51872
12
    }
51873
3.41k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51874
37
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51875
37
      d1 = Z_DVAL_P(op1);
51876
37
      d2 = Z_DVAL_P(op2);
51877
49
is_not_equal_double:
51878
49
      if (d1 != d2) {
51879
49
        goto is_not_equal_true;
51880
49
      } else {
51881
0
        goto is_not_equal_false;
51882
0
      }
51883
49
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51884
0
      d1 = Z_DVAL_P(op1);
51885
0
      d2 = (double)Z_LVAL_P(op2);
51886
0
      goto is_not_equal_double;
51887
0
    }
51888
3.37k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51889
483
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51890
147
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51891
147
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51892
0
        zval_ptr_dtor_str(op1);
51893
0
      }
51894
147
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51895
0
        zval_ptr_dtor_str(op2);
51896
0
      }
51897
147
      if (!result) {
51898
48
        goto is_not_equal_true;
51899
99
      } else {
51900
99
        goto is_not_equal_false;
51901
99
      }
51902
147
    }
51903
483
  }
51904
3.90k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51905
3.90k
}
51906
51907
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51908
2.38k
{
51909
2.38k
  USE_OPLINE
51910
2.38k
  zval *op1, *op2;
51911
2.38k
  double d1, d2;
51912
51913
2.38k
  op1 = EX_VAR(opline->op1.var);
51914
2.38k
  op2 = EX_VAR(opline->op2.var);
51915
2.38k
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51916
    /* pass */
51917
2.38k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51918
889
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51919
878
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51920
812
is_not_equal_true:
51921
812
        ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
51922
812
      } else {
51923
100
is_not_equal_false:
51924
100
        ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
51925
100
      }
51926
878
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51927
11
      d1 = (double)Z_LVAL_P(op1);
51928
11
      d2 = Z_DVAL_P(op2);
51929
11
      goto is_not_equal_double;
51930
11
    }
51931
1.49k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51932
25
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51933
23
      d1 = Z_DVAL_P(op1);
51934
23
      d2 = Z_DVAL_P(op2);
51935
34
is_not_equal_double:
51936
34
      if (d1 != d2) {
51937
34
        goto is_not_equal_true;
51938
34
      } else {
51939
0
        goto is_not_equal_false;
51940
0
      }
51941
34
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51942
0
      d1 = Z_DVAL_P(op1);
51943
0
      d2 = (double)Z_LVAL_P(op2);
51944
0
      goto is_not_equal_double;
51945
0
    }
51946
1.47k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51947
542
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51948
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51949
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51950
0
        zval_ptr_dtor_str(op1);
51951
0
      }
51952
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51953
0
        zval_ptr_dtor_str(op2);
51954
0
      }
51955
0
      if (!result) {
51956
0
        goto is_not_equal_true;
51957
0
      } else {
51958
0
        goto is_not_equal_false;
51959
0
      }
51960
0
    }
51961
542
  }
51962
2.38k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
51963
2.38k
}
51964
51965
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51966
3.65k
{
51967
3.65k
  USE_OPLINE
51968
3.65k
  zval *op1, *op2;
51969
3.65k
  double d1, d2;
51970
51971
3.65k
  op1 = EX_VAR(opline->op1.var);
51972
3.65k
  op2 = EX_VAR(opline->op2.var);
51973
3.65k
  if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51974
    /* pass */
51975
3.65k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51976
2.15k
    if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51977
2.09k
      if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51978
1.99k
is_not_equal_true:
51979
1.99k
        ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
51980
1.99k
      } else {
51981
226
is_not_equal_false:
51982
226
        ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
51983
226
      }
51984
2.09k
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51985
63
      d1 = (double)Z_LVAL_P(op1);
51986
63
      d2 = Z_DVAL_P(op2);
51987
63
      goto is_not_equal_double;
51988
63
    }
51989
2.15k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51990
67
    if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51991
67
      d1 = Z_DVAL_P(op1);
51992
67
      d2 = Z_DVAL_P(op2);
51993
130
is_not_equal_double:
51994
130
      if (d1 != d2) {
51995
76
        goto is_not_equal_true;
51996
76
      } else {
51997
54
        goto is_not_equal_false;
51998
54
      }
51999
130
    } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
52000
0
      d1 = Z_DVAL_P(op1);
52001
0
      d2 = (double)Z_LVAL_P(op2);
52002
0
      goto is_not_equal_double;
52003
0
    }
52004
1.43k
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
52005
130
    if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
52006
0
      bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
52007
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52008
0
        zval_ptr_dtor_str(op1);
52009
0
      }
52010
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52011
0
        zval_ptr_dtor_str(op2);
52012
0
      }
52013
0
      if (!result) {
52014
0
        goto is_not_equal_true;
52015
0
      } else {
52016
0
        goto is_not_equal_false;
52017
0
      }
52018
0
    }
52019
130
  }
52020
3.65k
  ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2));
52021
3.65k
}
52022
52023
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52024
56
{
52025
56
  USE_OPLINE
52026
56
  zval *op1, *op2;
52027
52028
56
  SAVE_OPLINE();
52029
56
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
52030
56
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52031
56
  compare_function(EX_VAR(opline->result.var), op1, op2);
52032
52033
52034
56
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52035
56
}
52036
52037
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52038
0
{
52039
0
  USE_OPLINE
52040
0
  zval *op1, *op2;
52041
52042
0
  SAVE_OPLINE();
52043
0
  op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
52044
0
  op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52045
0
  boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
52046
52047
52048
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52049
0
}
52050
52051
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52052
123
{
52053
123
  USE_OPLINE
52054
123
  zval *object;
52055
123
  zval *property;
52056
123
  zval *value;
52057
123
  zval *zptr;
52058
123
  void *_cache_slot[3] = {0};
52059
123
  void **cache_slot;
52060
123
  zend_property_info *prop_info;
52061
123
  zend_object *zobj;
52062
123
  zend_string *name, *tmp_name;
52063
52064
123
  SAVE_OPLINE();
52065
123
  object = EX_VAR(opline->op1.var);
52066
123
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52067
52068
123
  do {
52069
123
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
52070
52071
123
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52072
14
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52073
0
        object = Z_REFVAL_P(object);
52074
0
        goto assign_op_object;
52075
0
      }
52076
14
      if (IS_CV == IS_CV
52077
14
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52078
14
        ZVAL_UNDEFINED_OP1();
52079
14
      }
52080
14
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52081
14
      break;
52082
14
    }
52083
52084
109
assign_op_object:
52085
    /* here we are sure we are dealing with an object */
52086
109
    zobj = Z_OBJ_P(object);
52087
109
    if (IS_CV == IS_CONST) {
52088
0
      name = Z_STR_P(property);
52089
109
    } else {
52090
109
      name = zval_try_get_tmp_string(property, &tmp_name);
52091
109
      if (UNEXPECTED(!name)) {
52092
0
        UNDEF_RESULT();
52093
0
        break;
52094
0
      }
52095
109
    }
52096
109
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
52097
109
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52098
109
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52099
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52100
0
          ZVAL_NULL(EX_VAR(opline->result.var));
52101
0
        }
52102
109
      } else {
52103
109
        zend_reference *ref;
52104
52105
109
        do {
52106
109
          if (UNEXPECTED(Z_ISREF_P(zptr))) {
52107
0
            ref = Z_REF_P(zptr);
52108
0
            zptr = Z_REFVAL_P(zptr);
52109
0
            if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52110
0
              zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52111
0
              break;
52112
0
            }
52113
0
          }
52114
52115
109
          prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
52116
109
          if (prop_info) {
52117
            /* special case for typed properties */
52118
16
            zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
52119
93
          } else {
52120
93
            zend_binary_op(zptr, zptr, value OPLINE_CC);
52121
93
          }
52122
109
        } while (0);
52123
52124
109
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52125
39
          ZVAL_COPY(EX_VAR(opline->result.var), zptr);
52126
39
        }
52127
109
      }
52128
109
    } else {
52129
0
      zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
52130
0
    }
52131
109
    if (IS_CV != IS_CONST) {
52132
109
      zend_tmp_string_release(tmp_name);
52133
109
    }
52134
109
  } while (0);
52135
52136
123
  FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52137
52138
52139
  /* assign_obj has two opcodes! */
52140
123
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
52141
123
}
52142
52143
/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
52144
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52145
2.32k
{
52146
2.32k
  USE_OPLINE
52147
2.32k
  zval *var_ptr;
52148
2.32k
  zval *value, *container, *dim;
52149
2.32k
  HashTable *ht;
52150
52151
2.32k
  SAVE_OPLINE();
52152
2.32k
  container = EX_VAR(opline->op1.var);
52153
52154
2.32k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52155
2.29k
assign_dim_op_array:
52156
2.29k
    SEPARATE_ARRAY(container);
52157
2.29k
    ht = Z_ARRVAL_P(container);
52158
2.32k
assign_dim_op_new_array:
52159
2.32k
    dim = EX_VAR(opline->op2.var);
52160
2.32k
    if (IS_CV == IS_UNUSED) {
52161
0
      var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
52162
0
      if (UNEXPECTED(!var_ptr)) {
52163
0
        zend_cannot_add_element();
52164
0
        goto assign_dim_op_ret_null;
52165
0
      }
52166
2.32k
    } else {
52167
2.32k
      if (IS_CV == IS_CONST) {
52168
0
        var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
52169
2.32k
      } else {
52170
2.32k
        var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
52171
2.32k
      }
52172
2.32k
      if (UNEXPECTED(!var_ptr)) {
52173
5
        goto assign_dim_op_ret_null;
52174
5
      }
52175
2.32k
    }
52176
52177
2.32k
    value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
52178
52179
2.32k
    do {
52180
2.32k
      if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
52181
0
        zend_reference *ref = Z_REF_P(var_ptr);
52182
0
        var_ptr = Z_REFVAL_P(var_ptr);
52183
0
        if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52184
0
          zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52185
0
          break;
52186
0
        }
52187
0
      }
52188
2.32k
      zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
52189
2.32k
    } while (0);
52190
52191
2.32k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52192
46
      ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
52193
46
    }
52194
2.32k
    FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52195
2.32k
  } else {
52196
38
    if (EXPECTED(Z_ISREF_P(container))) {
52197
0
      container = Z_REFVAL_P(container);
52198
0
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52199
0
        goto assign_dim_op_array;
52200
0
      }
52201
0
    }
52202
52203
38
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52204
2
      zend_object *obj = Z_OBJ_P(container);
52205
52206
2
      dim = EX_VAR(opline->op2.var);
52207
2
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52208
0
        dim++;
52209
0
      }
52210
2
      zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
52211
36
    } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
52212
36
      uint8_t old_type;
52213
52214
36
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
52215
36
        ZVAL_UNDEFINED_OP1();
52216
36
      }
52217
36
      ht = zend_new_array(8);
52218
36
      old_type = Z_TYPE_P(container);
52219
36
      ZVAL_ARR(container, ht);
52220
36
      if (UNEXPECTED(old_type == IS_FALSE)) {
52221
0
        GC_ADDREF(ht);
52222
0
        zend_false_to_array_deprecated();
52223
0
        if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52224
0
          zend_array_destroy(ht);
52225
0
          goto assign_dim_op_ret_null;
52226
0
        }
52227
0
      }
52228
36
      goto assign_dim_op_new_array;
52229
36
    } else {
52230
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52231
0
      zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
52232
5
assign_dim_op_ret_null:
52233
5
      FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52234
5
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52235
0
        ZVAL_NULL(EX_VAR(opline->result.var));
52236
0
      }
52237
5
    }
52238
38
  }
52239
52240
52241
2.32k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
52242
2.32k
}
52243
52244
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52245
17.4k
{
52246
17.4k
  USE_OPLINE
52247
17.4k
  zval *var_ptr;
52248
17.4k
  zval *value;
52249
52250
17.4k
  SAVE_OPLINE();
52251
17.4k
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52252
17.4k
  var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
52253
52254
17.4k
  do {
52255
17.4k
    if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
52256
3.68k
      zend_reference *ref = Z_REF_P(var_ptr);
52257
3.68k
      var_ptr = Z_REFVAL_P(var_ptr);
52258
3.68k
      if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52259
0
        zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52260
0
        break;
52261
0
      }
52262
3.68k
    }
52263
17.4k
    zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
52264
17.4k
  } while (0);
52265
52266
17.4k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52267
5.78k
    ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
52268
5.78k
  }
52269
52270
52271
17.4k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52272
17.4k
}
52273
52274
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52275
23
{
52276
23
  USE_OPLINE
52277
23
  zval *object;
52278
23
  zval *property;
52279
23
  zval *zptr;
52280
23
  void *_cache_slot[3] = {0};
52281
23
  void **cache_slot;
52282
23
  zend_property_info *prop_info;
52283
23
  zend_object *zobj;
52284
23
  zend_string *name, *tmp_name;
52285
52286
23
  SAVE_OPLINE();
52287
23
  object = EX_VAR(opline->op1.var);
52288
23
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52289
52290
23
  do {
52291
23
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52292
2
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52293
0
        object = Z_REFVAL_P(object);
52294
0
        goto pre_incdec_object;
52295
0
      }
52296
2
      if (IS_CV == IS_CV
52297
2
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52298
2
        ZVAL_UNDEFINED_OP1();
52299
2
      }
52300
2
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52301
2
      break;
52302
2
    }
52303
52304
21
pre_incdec_object:
52305
    /* here we are sure we are dealing with an object */
52306
21
    zobj = Z_OBJ_P(object);
52307
21
    if (IS_CV == IS_CONST) {
52308
0
      name = Z_STR_P(property);
52309
21
    } else {
52310
21
      name = zval_try_get_tmp_string(property, &tmp_name);
52311
21
      if (UNEXPECTED(!name)) {
52312
0
        UNDEF_RESULT();
52313
0
        break;
52314
0
      }
52315
21
    }
52316
21
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
52317
21
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52318
21
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52319
0
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52320
0
          ZVAL_NULL(EX_VAR(opline->result.var));
52321
0
        }
52322
21
      } else {
52323
21
        prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
52324
21
        zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
52325
21
      }
52326
21
    } else {
52327
0
      zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
52328
0
    }
52329
21
    if (IS_CV != IS_CONST) {
52330
21
      zend_tmp_string_release(tmp_name);
52331
21
    }
52332
21
  } while (0);
52333
52334
52335
23
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52336
23
}
52337
52338
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52339
18
{
52340
18
  USE_OPLINE
52341
18
  zval *object;
52342
18
  zval *property;
52343
18
  zval *zptr;
52344
18
  void *_cache_slot[3] = {0};
52345
18
  void **cache_slot;
52346
18
  zend_property_info *prop_info;
52347
18
  zend_object *zobj;
52348
18
  zend_string *name, *tmp_name;
52349
52350
18
  SAVE_OPLINE();
52351
18
  object = EX_VAR(opline->op1.var);
52352
18
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52353
52354
18
  do {
52355
18
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52356
2
      if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52357
0
        object = Z_REFVAL_P(object);
52358
0
        goto post_incdec_object;
52359
0
      }
52360
2
      if (IS_CV == IS_CV
52361
2
       && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52362
2
        ZVAL_UNDEFINED_OP1();
52363
2
      }
52364
2
      zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52365
2
      break;
52366
2
    }
52367
52368
16
post_incdec_object:
52369
    /* here we are sure we are dealing with an object */
52370
16
    zobj = Z_OBJ_P(object);
52371
16
    if (IS_CV == IS_CONST) {
52372
0
      name = Z_STR_P(property);
52373
16
    } else {
52374
16
      name = zval_try_get_tmp_string(property, &tmp_name);
52375
16
      if (UNEXPECTED(!name)) {
52376
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
52377
0
        break;
52378
0
      }
52379
16
    }
52380
16
    cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
52381
16
    if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52382
16
      if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52383
0
        ZVAL_NULL(EX_VAR(opline->result.var));
52384
16
      } else {
52385
16
        prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
52386
16
        zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
52387
16
      }
52388
16
    } else {
52389
0
      zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
52390
0
    }
52391
16
    if (IS_CV != IS_CONST) {
52392
16
      zend_tmp_string_release(tmp_name);
52393
16
    }
52394
16
  } while (0);
52395
52396
52397
18
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52398
18
}
52399
52400
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52401
7.14k
{
52402
7.14k
  USE_OPLINE
52403
7.14k
  zval *container, *dim, *value;
52404
52405
7.14k
  SAVE_OPLINE();
52406
7.14k
  container = EX_VAR(opline->op1.var);
52407
7.14k
  dim = EX_VAR(opline->op2.var);
52408
7.14k
  if (IS_CV != IS_CONST) {
52409
7.14k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52410
3.59k
fetch_dim_r_array:
52411
3.59k
      value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
52412
3.59k
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
52413
3.59k
    } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
52414
34
      container = Z_REFVAL_P(container);
52415
34
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52416
30
        goto fetch_dim_r_array;
52417
30
      } else {
52418
4
        goto fetch_dim_r_slow;
52419
4
      }
52420
3.54k
    } else {
52421
3.54k
fetch_dim_r_slow:
52422
3.54k
      if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52423
0
        dim++;
52424
0
      }
52425
3.54k
      zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
52426
3.54k
    }
52427
7.14k
  } else {
52428
0
    zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
52429
0
  }
52430
52431
52432
7.14k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52433
7.14k
}
52434
52435
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52436
9.37k
{
52437
9.37k
  USE_OPLINE
52438
9.37k
  zval *container;
52439
52440
9.37k
  SAVE_OPLINE();
52441
9.37k
  container = EX_VAR(opline->op1.var);
52442
9.37k
  zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52443
52444
9.37k
  if (IS_CV == IS_VAR) {
52445
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52446
0
  }
52447
9.37k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52448
9.37k
}
52449
52450
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52451
41
{
52452
41
  USE_OPLINE
52453
41
  zval *container;
52454
52455
41
  SAVE_OPLINE();
52456
41
  container = EX_VAR(opline->op1.var);
52457
41
  zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52458
52459
41
  if (IS_CV == IS_VAR) {
52460
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52461
0
  }
52462
41
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52463
41
}
52464
52465
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52466
65
{
52467
65
  USE_OPLINE
52468
65
  zval *container;
52469
52470
65
  SAVE_OPLINE();
52471
65
  container = EX_VAR(opline->op1.var);
52472
65
  zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52473
52474
52475
65
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52476
65
}
52477
52478
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52479
0
{
52480
#if 0
52481
  USE_OPLINE
52482
#endif
52483
52484
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
52485
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
52486
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52487
0
    }
52488
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52489
0
  } else {
52490
0
    if (IS_CV == IS_UNUSED) {
52491
0
      ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52492
0
    }
52493
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52494
0
  }
52495
0
}
52496
52497
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52498
0
{
52499
0
  USE_OPLINE
52500
0
  zval *container;
52501
52502
0
  SAVE_OPLINE();
52503
0
  container = EX_VAR(opline->op1.var);
52504
0
  zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52505
52506
0
  if (IS_CV == IS_VAR) {
52507
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52508
0
  }
52509
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52510
0
}
52511
52512
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52513
508
{
52514
508
  USE_OPLINE
52515
508
  zval *container;
52516
508
  void **cache_slot = NULL;
52517
52518
508
  SAVE_OPLINE();
52519
508
  container = EX_VAR(opline->op1.var);
52520
52521
508
  if (IS_CV == IS_CONST ||
52522
508
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
52523
142
    do {
52524
142
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
52525
17
        container = Z_REFVAL_P(container);
52526
17
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52527
17
          break;
52528
17
        }
52529
17
      }
52530
125
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
52531
101
        ZVAL_UNDEFINED_OP1();
52532
101
      }
52533
125
      zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52534
125
      ZVAL_NULL(EX_VAR(opline->result.var));
52535
125
      goto fetch_obj_r_finish;
52536
142
    } while (0);
52537
142
  }
52538
52539
  /* here we are sure we are dealing with an object */
52540
383
  do {
52541
383
    zend_object *zobj = Z_OBJ_P(container);
52542
383
    zend_string *name, *tmp_name;
52543
383
    zval *retval;
52544
52545
383
    if (IS_CV == IS_CONST) {
52546
0
      cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
52547
52548
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
52549
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52550
52551
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52552
0
fetch_obj_r_simple:
52553
0
          retval = OBJ_PROP(zobj, prop_offset);
52554
0
          if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
52555
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52556
0
              goto fetch_obj_r_copy;
52557
0
            } else {
52558
0
fetch_obj_r_fast_copy:
52559
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52560
0
              ZEND_VM_NEXT_OPCODE();
52561
0
            }
52562
0
          }
52563
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
52564
0
          zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52565
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
52566
0
            prop_offset = prop_info->offset;
52567
0
            goto fetch_obj_r_simple;
52568
0
          } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
52569
0
            zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
52570
0
            ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
52571
0
            ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
52572
52573
0
            uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
52574
0
            if (IS_CV & IS_CV) {
52575
0
              GC_ADDREF(zobj);
52576
0
            }
52577
0
            if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
52578
0
              call_info |= ZEND_CALL_RELEASE_THIS;
52579
0
            }
52580
0
            zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
52581
0
            call->prev_execute_data = execute_data;
52582
0
            call->call = NULL;
52583
0
            call->return_value = EX_VAR(opline->result.var);
52584
0
            call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
52585
52586
0
            execute_data = call;
52587
0
            EG(current_execute_data) = execute_data;
52588
0
            zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
52589
52590
#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
52591
            opline = hook->op_array.opcodes;
52592
#else
52593
0
            EX(opline) = hook->op_array.opcodes;
52594
0
#endif
52595
0
            LOAD_OPLINE_EX();
52596
52597
52598
0
            ZEND_VM_ENTER_EX();
52599
0
          }
52600
          /* Fall through to read_property for hooks. */
52601
0
        } else if (EXPECTED(zobj->properties != NULL)) {
52602
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
52603
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52604
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
52605
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
52606
52607
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
52608
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
52609
52610
0
              if (EXPECTED(p->key == name) ||
52611
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
52612
0
                   EXPECTED(p->key != NULL) &&
52613
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
52614
0
                retval = &p->val;
52615
0
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52616
0
                  goto fetch_obj_r_copy;
52617
0
                } else {
52618
0
                  goto fetch_obj_r_fast_copy;
52619
0
                }
52620
0
              }
52621
0
            }
52622
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
52623
0
          }
52624
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
52625
0
          if (EXPECTED(retval)) {
52626
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
52627
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
52628
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52629
0
              goto fetch_obj_r_copy;
52630
0
            } else {
52631
0
              goto fetch_obj_r_fast_copy;
52632
0
            }
52633
0
          }
52634
0
        }
52635
0
      }
52636
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52637
383
    } else {
52638
383
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52639
383
      if (UNEXPECTED(!name)) {
52640
3
        ZVAL_UNDEF(EX_VAR(opline->result.var));
52641
3
        break;
52642
3
      }
52643
383
    }
52644
52645
380
#if ZEND_DEBUG
52646
    /* For non-standard object handlers, verify a declared property type in debug builds.
52647
     * Fetch prop_info before calling read_property(), as it may deallocate the object. */
52648
380
    zend_property_info *prop_info = NULL;
52649
380
    if (zobj->handlers->read_property != zend_std_read_property) {
52650
0
      prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
52651
0
    }
52652
380
#endif
52653
380
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
52654
380
#if ZEND_DEBUG
52655
380
    if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
52656
380
        && ZEND_TYPE_IS_SET(prop_info->type)) {
52657
0
      ZVAL_OPT_DEREF(retval);
52658
0
      zend_verify_property_type(prop_info, retval, /* strict */ true);
52659
0
    }
52660
380
#endif
52661
52662
380
    if (IS_CV != IS_CONST) {
52663
380
      zend_tmp_string_release(tmp_name);
52664
380
    }
52665
52666
380
    if (retval != EX_VAR(opline->result.var)) {
52667
336
fetch_obj_r_copy:
52668
336
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52669
336
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
52670
0
      zend_unwrap_reference(retval);
52671
0
    }
52672
380
  } while (0);
52673
52674
508
fetch_obj_r_finish:
52675
52676
52677
508
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52678
508
}
52679
52680
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52681
797
{
52682
797
  USE_OPLINE
52683
797
  zval *property, *container, *result;
52684
52685
797
  SAVE_OPLINE();
52686
52687
797
  container = EX_VAR(opline->op1.var);
52688
797
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52689
797
  result = EX_VAR(opline->result.var);
52690
797
  zend_fetch_property_address(
52691
797
    result, container, IS_CV, property, IS_CV,
52692
797
    ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
52693
797
    BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
52694
52695
797
  if (IS_CV == IS_VAR) {
52696
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52697
0
  }
52698
797
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52699
797
}
52700
52701
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52702
2
{
52703
2
  USE_OPLINE
52704
2
  zval *property, *container, *result;
52705
52706
2
  SAVE_OPLINE();
52707
2
  container = EX_VAR(opline->op1.var);
52708
2
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52709
2
  result = EX_VAR(opline->result.var);
52710
2
  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);
52711
52712
2
  if (IS_CV == IS_VAR) {
52713
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52714
0
  }
52715
2
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52716
2
}
52717
52718
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52719
165
{
52720
165
  USE_OPLINE
52721
165
  zval *container;
52722
165
  void **cache_slot = NULL;
52723
52724
165
  SAVE_OPLINE();
52725
165
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
52726
52727
165
  if (IS_CV == IS_CONST ||
52728
165
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
52729
5
    do {
52730
5
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
52731
5
        container = Z_REFVAL_P(container);
52732
5
        if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52733
5
          break;
52734
5
        }
52735
5
      }
52736
0
      if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
52737
0
        ZVAL_UNDEFINED_OP2();
52738
0
      }
52739
0
      ZVAL_NULL(EX_VAR(opline->result.var));
52740
0
      goto fetch_obj_is_finish;
52741
5
    } while (0);
52742
5
  }
52743
52744
  /* here we are sure we are dealing with an object */
52745
165
  do {
52746
165
    zend_object *zobj = Z_OBJ_P(container);
52747
165
    zend_string *name, *tmp_name;
52748
165
    zval *retval;
52749
52750
165
    if (IS_CV == IS_CONST) {
52751
0
      cache_slot = CACHE_ADDR(opline->extended_value);
52752
52753
0
      if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
52754
0
        uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52755
52756
0
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52757
0
fetch_obj_is_simple:
52758
0
          retval = OBJ_PROP(zobj, prop_offset);
52759
0
          if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
52760
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52761
0
              goto fetch_obj_is_copy;
52762
0
            } else {
52763
0
fetch_obj_is_fast_copy:
52764
0
              ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52765
0
              ZEND_VM_NEXT_OPCODE();
52766
0
            }
52767
0
          }
52768
0
        } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
52769
0
          if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
52770
0
            zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52771
0
            prop_offset = prop_info->offset;
52772
0
            goto fetch_obj_is_simple;
52773
0
          }
52774
          /* Fall through to read_property for hooks. */
52775
0
        } else if (EXPECTED(zobj->properties != NULL)) {
52776
0
          ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
52777
0
          name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52778
0
          if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
52779
0
            uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
52780
52781
0
            if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
52782
0
              Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
52783
52784
0
              if (EXPECTED(p->key == name) ||
52785
0
                  (EXPECTED(p->h == ZSTR_H(name)) &&
52786
0
                   EXPECTED(p->key != NULL) &&
52787
0
                   EXPECTED(zend_string_equal_content(p->key, name)))) {
52788
0
                retval = &p->val;
52789
0
                if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52790
0
                  goto fetch_obj_is_copy;
52791
0
                } else {
52792
0
                  goto fetch_obj_is_fast_copy;
52793
0
                }
52794
0
              }
52795
0
            }
52796
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
52797
0
          }
52798
0
          retval = zend_hash_find_known_hash(zobj->properties, name);
52799
0
          if (EXPECTED(retval)) {
52800
0
            uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
52801
0
            CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
52802
0
            if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52803
0
              goto fetch_obj_is_copy;
52804
0
            } else {
52805
0
              goto fetch_obj_is_fast_copy;
52806
0
            }
52807
0
          }
52808
0
        }
52809
0
      }
52810
0
      name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52811
165
    } else {
52812
165
      name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52813
165
      if (UNEXPECTED(!name)) {
52814
0
        ZVAL_UNDEF(EX_VAR(opline->result.var));
52815
0
        break;
52816
0
      }
52817
165
    }
52818
52819
165
    retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
52820
52821
165
    if (IS_CV != IS_CONST) {
52822
165
      zend_tmp_string_release(tmp_name);
52823
165
    }
52824
52825
165
    if (retval != EX_VAR(opline->result.var)) {
52826
157
fetch_obj_is_copy:
52827
157
      ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52828
157
    } else if (UNEXPECTED(Z_ISREF_P(retval))) {
52829
0
      zend_unwrap_reference(retval);
52830
0
    }
52831
165
  } while (0);
52832
52833
165
fetch_obj_is_finish:
52834
52835
52836
165
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52837
165
}
52838
52839
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52840
0
{
52841
#if 0
52842
  USE_OPLINE
52843
#endif
52844
52845
0
  if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
52846
    /* Behave like FETCH_OBJ_W */
52847
0
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
52848
0
      ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52849
0
    }
52850
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52851
0
  } else {
52852
0
    ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52853
0
  }
52854
0
}
52855
52856
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52857
0
{
52858
0
  USE_OPLINE
52859
0
  zval *container, *property, *result;
52860
52861
0
  SAVE_OPLINE();
52862
0
  container = EX_VAR(opline->op1.var);
52863
0
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52864
0
  result = EX_VAR(opline->result.var);
52865
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);
52866
52867
0
  if (IS_CV == IS_VAR) {
52868
0
    FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52869
0
  }
52870
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52871
0
}
52872
52873
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52874
169
{
52875
169
  USE_OPLINE
52876
169
  zval *object, *value, tmp;
52877
169
  zend_object *zobj;
52878
169
  zend_string *name, *tmp_name;
52879
169
  zend_refcounted *garbage = NULL;
52880
52881
169
  SAVE_OPLINE();
52882
169
  object = EX_VAR(opline->op1.var);
52883
169
  value = RT_CONSTANT((opline+1), (opline+1)->op1);
52884
52885
169
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52886
3
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52887
0
      object = Z_REFVAL_P(object);
52888
0
      goto assign_object;
52889
0
    }
52890
3
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
52891
3
    value = &EG(uninitialized_zval);
52892
3
    goto free_and_exit_assign_obj;
52893
3
  }
52894
52895
166
assign_object:
52896
166
  zobj = Z_OBJ_P(object);
52897
166
  if (IS_CV == IS_CONST) {
52898
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
52899
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
52900
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52901
0
      zval *property_val;
52902
0
      zend_property_info *prop_info;
52903
52904
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52905
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
52906
52907
0
assign_obj_simple:
52908
0
        property_val = OBJ_PROP(zobj, prop_offset);
52909
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
52910
0
          if (prop_info != NULL) {
52911
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
52912
0
            goto free_and_exit_assign_obj;
52913
0
          } else {
52914
0
fast_assign_obj:
52915
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
52916
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52917
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
52918
0
            }
52919
0
            goto exit_assign_obj;
52920
0
          }
52921
0
        }
52922
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
52923
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52924
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
52925
0
          zobj = zend_lazy_object_init(zobj);
52926
0
          if (!zobj) {
52927
0
            value = &EG(uninitialized_zval);
52928
0
            goto free_and_exit_assign_obj;
52929
0
          }
52930
0
        }
52931
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52932
0
          rebuild_object_properties_internal(zobj);
52933
0
        }
52934
0
        if (EXPECTED(zobj->properties != NULL)) {
52935
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
52936
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
52937
0
              GC_DELREF(zobj->properties);
52938
0
            }
52939
0
            zobj->properties = zend_array_dup(zobj->properties);
52940
0
          }
52941
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
52942
0
          if (property_val) {
52943
0
            goto fast_assign_obj;
52944
0
          }
52945
0
        }
52946
52947
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52948
0
          if (IS_CONST == IS_CONST) {
52949
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
52950
0
              Z_ADDREF_P(value);
52951
0
            }
52952
0
          } else if (IS_CONST != IS_TMP_VAR) {
52953
0
            if (Z_ISREF_P(value)) {
52954
0
              if (IS_CONST == IS_VAR) {
52955
0
                zend_reference *ref = Z_REF_P(value);
52956
0
                if (GC_DELREF(ref) == 0) {
52957
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
52958
0
                  efree_size(ref, sizeof(zend_reference));
52959
0
                  value = &tmp;
52960
0
                } else {
52961
0
                  value = Z_REFVAL_P(value);
52962
0
                  Z_TRY_ADDREF_P(value);
52963
0
                }
52964
0
              } else {
52965
0
                value = Z_REFVAL_P(value);
52966
0
                Z_TRY_ADDREF_P(value);
52967
0
              }
52968
0
            } else if (IS_CONST == IS_CV) {
52969
0
              Z_TRY_ADDREF_P(value);
52970
0
            }
52971
0
          }
52972
0
          zend_hash_add_new(zobj->properties, name, value);
52973
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52974
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
52975
0
          }
52976
0
          goto exit_assign_obj;
52977
0
        }
52978
0
      } else {
52979
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
52980
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
52981
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
52982
0
          prop_offset = prop_info->offset;
52983
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
52984
0
            prop_info = NULL;
52985
0
          }
52986
0
          goto assign_obj_simple;
52987
0
        }
52988
        /* Fall through to write_property for hooks. */
52989
0
      }
52990
0
    }
52991
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52992
166
  } else {
52993
166
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52994
166
    if (UNEXPECTED(!name)) {
52995
52996
0
      UNDEF_RESULT();
52997
0
      goto exit_assign_obj;
52998
0
    }
52999
166
  }
53000
53001
166
  if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
53002
0
    ZVAL_DEREF(value);
53003
0
  }
53004
53005
166
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53006
53007
166
  if (IS_CV != IS_CONST) {
53008
166
    zend_tmp_string_release(tmp_name);
53009
166
  }
53010
53011
169
free_and_exit_assign_obj:
53012
169
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53013
6
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53014
6
  }
53015
53016
169
exit_assign_obj:
53017
169
  if (garbage) {
53018
0
    GC_DTOR_NO_REF(garbage);
53019
0
  }
53020
53021
53022
  /* assign_obj has two opcodes! */
53023
169
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53024
169
}
53025
53026
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53027
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53028
12
{
53029
12
  USE_OPLINE
53030
12
  zval *object, *value, tmp;
53031
12
  zend_object *zobj;
53032
12
  zend_string *name, *tmp_name;
53033
12
  zend_refcounted *garbage = NULL;
53034
53035
12
  SAVE_OPLINE();
53036
12
  object = EX_VAR(opline->op1.var);
53037
12
  value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53038
53039
12
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53040
12
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53041
10
      object = Z_REFVAL_P(object);
53042
10
      goto assign_object;
53043
10
    }
53044
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);
53045
2
    value = &EG(uninitialized_zval);
53046
2
    goto free_and_exit_assign_obj;
53047
12
  }
53048
53049
10
assign_object:
53050
10
  zobj = Z_OBJ_P(object);
53051
10
  if (IS_CV == IS_CONST) {
53052
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53053
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
53054
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53055
0
      zval *property_val;
53056
0
      zend_property_info *prop_info;
53057
53058
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53059
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53060
53061
0
assign_obj_simple:
53062
0
        property_val = OBJ_PROP(zobj, prop_offset);
53063
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
53064
0
          if (prop_info != NULL) {
53065
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53066
0
            goto free_and_exit_assign_obj;
53067
0
          } else {
53068
0
fast_assign_obj:
53069
0
            value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
53070
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53071
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
53072
0
            }
53073
0
            goto exit_assign_obj;
53074
0
          }
53075
0
        }
53076
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53077
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53078
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53079
0
          zobj = zend_lazy_object_init(zobj);
53080
0
          if (!zobj) {
53081
0
            value = &EG(uninitialized_zval);
53082
0
            goto free_and_exit_assign_obj;
53083
0
          }
53084
0
        }
53085
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53086
0
          rebuild_object_properties_internal(zobj);
53087
0
        }
53088
0
        if (EXPECTED(zobj->properties != NULL)) {
53089
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53090
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53091
0
              GC_DELREF(zobj->properties);
53092
0
            }
53093
0
            zobj->properties = zend_array_dup(zobj->properties);
53094
0
          }
53095
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
53096
0
          if (property_val) {
53097
0
            goto fast_assign_obj;
53098
0
          }
53099
0
        }
53100
53101
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53102
0
          if (IS_TMP_VAR == IS_CONST) {
53103
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53104
0
              Z_ADDREF_P(value);
53105
0
            }
53106
0
          } else if (IS_TMP_VAR != IS_TMP_VAR) {
53107
0
            if (Z_ISREF_P(value)) {
53108
0
              if (IS_TMP_VAR == IS_VAR) {
53109
0
                zend_reference *ref = Z_REF_P(value);
53110
0
                if (GC_DELREF(ref) == 0) {
53111
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53112
0
                  efree_size(ref, sizeof(zend_reference));
53113
0
                  value = &tmp;
53114
0
                } else {
53115
0
                  value = Z_REFVAL_P(value);
53116
0
                  Z_TRY_ADDREF_P(value);
53117
0
                }
53118
0
              } else {
53119
0
                value = Z_REFVAL_P(value);
53120
0
                Z_TRY_ADDREF_P(value);
53121
0
              }
53122
0
            } else if (IS_TMP_VAR == IS_CV) {
53123
0
              Z_TRY_ADDREF_P(value);
53124
0
            }
53125
0
          }
53126
0
          zend_hash_add_new(zobj->properties, name, value);
53127
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53128
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
53129
0
          }
53130
0
          goto exit_assign_obj;
53131
0
        }
53132
0
      } else {
53133
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53134
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53135
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
53136
0
          prop_offset = prop_info->offset;
53137
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53138
0
            prop_info = NULL;
53139
0
          }
53140
0
          goto assign_obj_simple;
53141
0
        }
53142
        /* Fall through to write_property for hooks. */
53143
0
      }
53144
0
    }
53145
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53146
10
  } else {
53147
10
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53148
10
    if (UNEXPECTED(!name)) {
53149
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53150
0
      UNDEF_RESULT();
53151
0
      goto exit_assign_obj;
53152
0
    }
53153
10
  }
53154
53155
10
  if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
53156
0
    ZVAL_DEREF(value);
53157
0
  }
53158
53159
10
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53160
53161
10
  if (IS_CV != IS_CONST) {
53162
10
    zend_tmp_string_release(tmp_name);
53163
10
  }
53164
53165
12
free_and_exit_assign_obj:
53166
12
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53167
0
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53168
0
  }
53169
12
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53170
12
exit_assign_obj:
53171
12
  if (garbage) {
53172
0
    GC_DTOR_NO_REF(garbage);
53173
0
  }
53174
53175
53176
  /* assign_obj has two opcodes! */
53177
12
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53178
12
}
53179
53180
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53181
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53182
166
{
53183
166
  USE_OPLINE
53184
166
  zval *object, *value, tmp;
53185
166
  zend_object *zobj;
53186
166
  zend_string *name, *tmp_name;
53187
166
  zend_refcounted *garbage = NULL;
53188
53189
166
  SAVE_OPLINE();
53190
166
  object = EX_VAR(opline->op1.var);
53191
166
  value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53192
53193
166
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53194
0
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53195
0
      object = Z_REFVAL_P(object);
53196
0
      goto assign_object;
53197
0
    }
53198
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);
53199
0
    value = &EG(uninitialized_zval);
53200
0
    goto free_and_exit_assign_obj;
53201
0
  }
53202
53203
166
assign_object:
53204
166
  zobj = Z_OBJ_P(object);
53205
166
  if (IS_CV == IS_CONST) {
53206
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53207
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
53208
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53209
0
      zval *property_val;
53210
0
      zend_property_info *prop_info;
53211
53212
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53213
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53214
53215
0
assign_obj_simple:
53216
0
        property_val = OBJ_PROP(zobj, prop_offset);
53217
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
53218
0
          if (prop_info != NULL) {
53219
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53220
0
            goto free_and_exit_assign_obj;
53221
0
          } else {
53222
0
fast_assign_obj:
53223
0
            value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
53224
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53225
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
53226
0
            }
53227
0
            goto exit_assign_obj;
53228
0
          }
53229
0
        }
53230
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53231
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53232
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53233
0
          zobj = zend_lazy_object_init(zobj);
53234
0
          if (!zobj) {
53235
0
            value = &EG(uninitialized_zval);
53236
0
            goto free_and_exit_assign_obj;
53237
0
          }
53238
0
        }
53239
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53240
0
          rebuild_object_properties_internal(zobj);
53241
0
        }
53242
0
        if (EXPECTED(zobj->properties != NULL)) {
53243
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53244
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53245
0
              GC_DELREF(zobj->properties);
53246
0
            }
53247
0
            zobj->properties = zend_array_dup(zobj->properties);
53248
0
          }
53249
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
53250
0
          if (property_val) {
53251
0
            goto fast_assign_obj;
53252
0
          }
53253
0
        }
53254
53255
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53256
0
          if (IS_VAR == IS_CONST) {
53257
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53258
0
              Z_ADDREF_P(value);
53259
0
            }
53260
0
          } else if (IS_VAR != IS_TMP_VAR) {
53261
0
            if (Z_ISREF_P(value)) {
53262
0
              if (IS_VAR == IS_VAR) {
53263
0
                zend_reference *ref = Z_REF_P(value);
53264
0
                if (GC_DELREF(ref) == 0) {
53265
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53266
0
                  efree_size(ref, sizeof(zend_reference));
53267
0
                  value = &tmp;
53268
0
                } else {
53269
0
                  value = Z_REFVAL_P(value);
53270
0
                  Z_TRY_ADDREF_P(value);
53271
0
                }
53272
0
              } else {
53273
0
                value = Z_REFVAL_P(value);
53274
0
                Z_TRY_ADDREF_P(value);
53275
0
              }
53276
0
            } else if (IS_VAR == IS_CV) {
53277
0
              Z_TRY_ADDREF_P(value);
53278
0
            }
53279
0
          }
53280
0
          zend_hash_add_new(zobj->properties, name, value);
53281
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53282
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
53283
0
          }
53284
0
          goto exit_assign_obj;
53285
0
        }
53286
0
      } else {
53287
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53288
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53289
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
53290
0
          prop_offset = prop_info->offset;
53291
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53292
0
            prop_info = NULL;
53293
0
          }
53294
0
          goto assign_obj_simple;
53295
0
        }
53296
        /* Fall through to write_property for hooks. */
53297
0
      }
53298
0
    }
53299
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53300
166
  } else {
53301
166
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53302
166
    if (UNEXPECTED(!name)) {
53303
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53304
0
      UNDEF_RESULT();
53305
0
      goto exit_assign_obj;
53306
0
    }
53307
166
  }
53308
53309
166
  if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
53310
166
    ZVAL_DEREF(value);
53311
166
  }
53312
53313
166
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53314
53315
166
  if (IS_CV != IS_CONST) {
53316
166
    zend_tmp_string_release(tmp_name);
53317
166
  }
53318
53319
166
free_and_exit_assign_obj:
53320
166
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53321
2
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53322
2
  }
53323
166
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53324
166
exit_assign_obj:
53325
166
  if (garbage) {
53326
0
    GC_DTOR_NO_REF(garbage);
53327
0
  }
53328
53329
53330
  /* assign_obj has two opcodes! */
53331
166
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53332
166
}
53333
53334
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53335
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53336
1.06k
{
53337
1.06k
  USE_OPLINE
53338
1.06k
  zval *object, *value, tmp;
53339
1.06k
  zend_object *zobj;
53340
1.06k
  zend_string *name, *tmp_name;
53341
1.06k
  zend_refcounted *garbage = NULL;
53342
53343
1.06k
  SAVE_OPLINE();
53344
1.06k
  object = EX_VAR(opline->op1.var);
53345
1.06k
  value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
53346
53347
1.06k
  if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53348
5
    if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53349
0
      object = Z_REFVAL_P(object);
53350
0
      goto assign_object;
53351
0
    }
53352
5
    zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
53353
5
    value = &EG(uninitialized_zval);
53354
5
    goto free_and_exit_assign_obj;
53355
5
  }
53356
53357
1.05k
assign_object:
53358
1.05k
  zobj = Z_OBJ_P(object);
53359
1.05k
  if (IS_CV == IS_CONST) {
53360
0
    if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53361
0
      void **cache_slot = CACHE_ADDR(opline->extended_value);
53362
0
      uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53363
0
      zval *property_val;
53364
0
      zend_property_info *prop_info;
53365
53366
0
      if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53367
0
        prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53368
53369
0
assign_obj_simple:
53370
0
        property_val = OBJ_PROP(zobj, prop_offset);
53371
0
        if (Z_TYPE_P(property_val) != IS_UNDEF) {
53372
0
          if (prop_info != NULL) {
53373
0
            value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53374
0
            goto free_and_exit_assign_obj;
53375
0
          } else {
53376
0
fast_assign_obj:
53377
0
            value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
53378
0
            if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53379
0
              ZVAL_COPY(EX_VAR(opline->result.var), value);
53380
0
            }
53381
0
            goto exit_assign_obj;
53382
0
          }
53383
0
        }
53384
0
      } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53385
0
        name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53386
0
        if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53387
0
          zobj = zend_lazy_object_init(zobj);
53388
0
          if (!zobj) {
53389
0
            value = &EG(uninitialized_zval);
53390
0
            goto free_and_exit_assign_obj;
53391
0
          }
53392
0
        }
53393
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53394
0
          rebuild_object_properties_internal(zobj);
53395
0
        }
53396
0
        if (EXPECTED(zobj->properties != NULL)) {
53397
0
          if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53398
0
            if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53399
0
              GC_DELREF(zobj->properties);
53400
0
            }
53401
0
            zobj->properties = zend_array_dup(zobj->properties);
53402
0
          }
53403
0
          property_val = zend_hash_find_known_hash(zobj->properties, name);
53404
0
          if (property_val) {
53405
0
            goto fast_assign_obj;
53406
0
          }
53407
0
        }
53408
53409
0
        if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53410
0
          if (IS_CV == IS_CONST) {
53411
0
            if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53412
0
              Z_ADDREF_P(value);
53413
0
            }
53414
0
          } else if (IS_CV != IS_TMP_VAR) {
53415
0
            if (Z_ISREF_P(value)) {
53416
0
              if (IS_CV == IS_VAR) {
53417
0
                zend_reference *ref = Z_REF_P(value);
53418
0
                if (GC_DELREF(ref) == 0) {
53419
0
                  ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53420
0
                  efree_size(ref, sizeof(zend_reference));
53421
0
                  value = &tmp;
53422
0
                } else {
53423
0
                  value = Z_REFVAL_P(value);
53424
0
                  Z_TRY_ADDREF_P(value);
53425
0
                }
53426
0
              } else {
53427
0
                value = Z_REFVAL_P(value);
53428
0
                Z_TRY_ADDREF_P(value);
53429
0
              }
53430
0
            } else if (IS_CV == IS_CV) {
53431
0
              Z_TRY_ADDREF_P(value);
53432
0
            }
53433
0
          }
53434
0
          zend_hash_add_new(zobj->properties, name, value);
53435
0
          if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53436
0
            ZVAL_COPY(EX_VAR(opline->result.var), value);
53437
0
          }
53438
0
          goto exit_assign_obj;
53439
0
        }
53440
0
      } else {
53441
0
        ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53442
0
        if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53443
0
          prop_info = CACHED_PTR_EX(cache_slot + 2);
53444
0
          prop_offset = prop_info->offset;
53445
0
          if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53446
0
            prop_info = NULL;
53447
0
          }
53448
0
          goto assign_obj_simple;
53449
0
        }
53450
        /* Fall through to write_property for hooks. */
53451
0
      }
53452
0
    }
53453
0
    name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53454
1.05k
  } else {
53455
1.05k
    name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53456
1.05k
    if (UNEXPECTED(!name)) {
53457
53458
15
      UNDEF_RESULT();
53459
15
      goto exit_assign_obj;
53460
15
    }
53461
1.05k
  }
53462
53463
1.04k
  if (IS_CV == IS_CV || IS_CV == IS_VAR) {
53464
1.04k
    ZVAL_DEREF(value);
53465
1.04k
  }
53466
53467
1.04k
  value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53468
53469
1.04k
  if (IS_CV != IS_CONST) {
53470
1.04k
    zend_tmp_string_release(tmp_name);
53471
1.04k
  }
53472
53473
1.04k
free_and_exit_assign_obj:
53474
1.04k
  if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53475
21
    ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53476
21
  }
53477
53478
1.06k
exit_assign_obj:
53479
1.06k
  if (garbage) {
53480
0
    GC_DTOR_NO_REF(garbage);
53481
0
  }
53482
53483
53484
  /* assign_obj has two opcodes! */
53485
1.06k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53486
1.06k
}
53487
53488
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53489
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53490
6.30k
{
53491
6.30k
  USE_OPLINE
53492
6.30k
  zval *object_ptr, *orig_object_ptr;
53493
6.30k
  zval *value;
53494
6.30k
  zval *variable_ptr;
53495
6.30k
  zval *dim;
53496
6.30k
  zend_refcounted *garbage = NULL;
53497
53498
6.30k
  SAVE_OPLINE();
53499
6.30k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53500
53501
6.30k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53502
5.96k
try_assign_dim_array:
53503
5.96k
    SEPARATE_ARRAY(object_ptr);
53504
5.96k
    if (IS_CV == IS_UNUSED) {
53505
0
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
53506
0
      if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53507
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
53508
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53509
0
          GC_ADDREF(ht);
53510
0
        }
53511
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53512
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53513
0
          zend_array_destroy(ht);
53514
0
          goto assign_dim_error;
53515
0
        }
53516
0
      }
53517
0
      if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
53518
0
        ZVAL_DEREF(value);
53519
0
      }
53520
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53521
0
      if (UNEXPECTED(value == NULL)) {
53522
0
        zend_cannot_add_element();
53523
0
        goto assign_dim_error;
53524
0
      } else if (IS_CONST == IS_CV) {
53525
0
        if (Z_REFCOUNTED_P(value)) {
53526
0
          Z_ADDREF_P(value);
53527
0
        }
53528
0
      } else if (IS_CONST == IS_VAR) {
53529
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
53530
0
        if (Z_ISREF_P(free_op_data)) {
53531
0
          if (Z_REFCOUNTED_P(value)) {
53532
0
            Z_ADDREF_P(value);
53533
0
          }
53534
0
          zval_ptr_dtor_nogc(free_op_data);
53535
0
        }
53536
0
      } else if (IS_CONST == IS_CONST) {
53537
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53538
0
          Z_ADDREF_P(value);
53539
0
        }
53540
0
      }
53541
5.96k
    } else {
53542
5.96k
      dim = EX_VAR(opline->op2.var);
53543
5.96k
      if (IS_CV == IS_CONST) {
53544
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53545
5.96k
      } else {
53546
5.96k
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53547
5.96k
      }
53548
5.96k
      if (UNEXPECTED(variable_ptr == NULL)) {
53549
9
        goto assign_dim_error;
53550
9
      }
53551
5.95k
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
53552
5.95k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
53553
5.95k
    }
53554
5.95k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53555
72
      ZVAL_COPY(EX_VAR(opline->result.var), value);
53556
72
    }
53557
5.95k
    if (garbage) {
53558
111
      GC_DTOR_NO_REF(garbage);
53559
111
    }
53560
5.95k
  } else {
53561
550
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
53562
167
      object_ptr = Z_REFVAL_P(object_ptr);
53563
167
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53564
167
        goto try_assign_dim_array;
53565
167
      }
53566
167
    }
53567
383
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53568
303
      zend_object *obj = Z_OBJ_P(object_ptr);
53569
53570
303
      GC_ADDREF(obj);
53571
303
      dim = EX_VAR(opline->op2.var);
53572
303
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53573
13
        dim = ZVAL_UNDEFINED_OP2();
53574
290
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53575
0
        dim++;
53576
0
      }
53577
53578
303
      value = RT_CONSTANT((opline+1), (opline+1)->op1);
53579
303
      if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53580
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53581
303
      } else if (IS_CONST & (IS_CV|IS_VAR)) {
53582
0
        ZVAL_DEREF(value);
53583
0
      }
53584
53585
303
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53586
53587
303
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53588
7
        zend_objects_store_del(obj);
53589
7
      }
53590
303
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53591
42
      if (IS_CV == IS_UNUSED) {
53592
0
        zend_use_new_element_for_string();
53593
53594
0
        UNDEF_RESULT();
53595
42
      } else {
53596
42
        dim = EX_VAR(opline->op2.var);
53597
42
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
53598
42
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53599
53600
42
      }
53601
42
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53602
38
      if (Z_ISREF_P(orig_object_ptr)
53603
38
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53604
38
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53605
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53606
53607
0
        UNDEF_RESULT();
53608
38
      } else {
53609
38
        HashTable *ht = zend_new_array(8);
53610
38
        uint8_t old_type = Z_TYPE_P(object_ptr);
53611
53612
38
        ZVAL_ARR(object_ptr, ht);
53613
38
        if (UNEXPECTED(old_type == IS_FALSE)) {
53614
0
          GC_ADDREF(ht);
53615
0
          zend_false_to_array_deprecated();
53616
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53617
0
            zend_array_destroy(ht);
53618
0
            goto assign_dim_error;
53619
0
          }
53620
0
        }
53621
38
        goto try_assign_dim_array;
53622
38
      }
53623
38
    } else {
53624
0
      zend_use_scalar_as_array();
53625
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53626
9
assign_dim_error:
53627
53628
9
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53629
0
        ZVAL_NULL(EX_VAR(opline->result.var));
53630
0
      }
53631
9
    }
53632
383
  }
53633
6.30k
  if (IS_CV != IS_UNUSED) {
53634
53635
6.30k
  }
53636
53637
  /* assign_dim has two opcodes! */
53638
6.30k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53639
6.30k
}
53640
53641
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53642
9.09k
{
53643
9.09k
  USE_OPLINE
53644
9.09k
  zval *object_ptr, *orig_object_ptr;
53645
9.09k
  zval *value;
53646
9.09k
  zval *variable_ptr;
53647
9.09k
  zval *dim;
53648
9.09k
  zend_refcounted *garbage = NULL;
53649
53650
9.09k
  SAVE_OPLINE();
53651
9.09k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53652
53653
9.09k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53654
9.02k
try_assign_dim_array:
53655
9.02k
    SEPARATE_ARRAY(object_ptr);
53656
9.02k
    if (IS_CV == IS_UNUSED) {
53657
0
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53658
0
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53659
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
53660
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53661
0
          GC_ADDREF(ht);
53662
0
        }
53663
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53664
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53665
0
          zend_array_destroy(ht);
53666
0
          goto assign_dim_error;
53667
0
        }
53668
0
      }
53669
0
      if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
53670
0
        ZVAL_DEREF(value);
53671
0
      }
53672
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53673
0
      if (UNEXPECTED(value == NULL)) {
53674
0
        zend_cannot_add_element();
53675
0
        goto assign_dim_error;
53676
0
      } else if (IS_TMP_VAR == IS_CV) {
53677
0
        if (Z_REFCOUNTED_P(value)) {
53678
0
          Z_ADDREF_P(value);
53679
0
        }
53680
0
      } else if (IS_TMP_VAR == IS_VAR) {
53681
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
53682
0
        if (Z_ISREF_P(free_op_data)) {
53683
0
          if (Z_REFCOUNTED_P(value)) {
53684
0
            Z_ADDREF_P(value);
53685
0
          }
53686
0
          zval_ptr_dtor_nogc(free_op_data);
53687
0
        }
53688
0
      } else if (IS_TMP_VAR == IS_CONST) {
53689
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53690
0
          Z_ADDREF_P(value);
53691
0
        }
53692
0
      }
53693
9.02k
    } else {
53694
9.02k
      dim = EX_VAR(opline->op2.var);
53695
9.02k
      if (IS_CV == IS_CONST) {
53696
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53697
9.02k
      } else {
53698
9.02k
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53699
9.02k
      }
53700
9.02k
      if (UNEXPECTED(variable_ptr == NULL)) {
53701
0
        goto assign_dim_error;
53702
0
      }
53703
9.02k
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53704
9.02k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
53705
9.02k
    }
53706
9.02k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53707
6.00k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
53708
6.00k
    }
53709
9.02k
    if (garbage) {
53710
12
      GC_DTOR_NO_REF(garbage);
53711
12
    }
53712
9.02k
  } else {
53713
170
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
53714
0
      object_ptr = Z_REFVAL_P(object_ptr);
53715
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53716
0
        goto try_assign_dim_array;
53717
0
      }
53718
0
    }
53719
170
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53720
73
      zend_object *obj = Z_OBJ_P(object_ptr);
53721
53722
73
      GC_ADDREF(obj);
53723
73
      dim = EX_VAR(opline->op2.var);
53724
73
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53725
2
        dim = ZVAL_UNDEFINED_OP2();
53726
71
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53727
0
        dim++;
53728
0
      }
53729
53730
73
      value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53731
73
      if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53732
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53733
73
      } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
53734
0
        ZVAL_DEREF(value);
53735
0
      }
53736
53737
73
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53738
53739
73
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53740
73
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53741
0
        zend_objects_store_del(obj);
53742
0
      }
53743
97
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53744
0
      if (IS_CV == IS_UNUSED) {
53745
0
        zend_use_new_element_for_string();
53746
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53747
0
        UNDEF_RESULT();
53748
0
      } else {
53749
0
        dim = EX_VAR(opline->op2.var);
53750
0
        value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53751
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53752
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53753
0
      }
53754
97
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53755
97
      if (Z_ISREF_P(orig_object_ptr)
53756
97
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53757
97
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53758
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53759
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53760
0
        UNDEF_RESULT();
53761
97
      } else {
53762
97
        HashTable *ht = zend_new_array(8);
53763
97
        uint8_t old_type = Z_TYPE_P(object_ptr);
53764
53765
97
        ZVAL_ARR(object_ptr, ht);
53766
97
        if (UNEXPECTED(old_type == IS_FALSE)) {
53767
0
          GC_ADDREF(ht);
53768
0
          zend_false_to_array_deprecated();
53769
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53770
0
            zend_array_destroy(ht);
53771
0
            goto assign_dim_error;
53772
0
          }
53773
0
        }
53774
97
        goto try_assign_dim_array;
53775
97
      }
53776
97
    } else {
53777
0
      zend_use_scalar_as_array();
53778
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53779
0
assign_dim_error:
53780
0
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53781
0
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53782
0
        ZVAL_NULL(EX_VAR(opline->result.var));
53783
0
      }
53784
0
    }
53785
170
  }
53786
9.09k
  if (IS_CV != IS_UNUSED) {
53787
53788
9.09k
  }
53789
53790
  /* assign_dim has two opcodes! */
53791
9.09k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53792
9.09k
}
53793
53794
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53795
77
{
53796
77
  USE_OPLINE
53797
77
  zval *object_ptr, *orig_object_ptr;
53798
77
  zval *value;
53799
77
  zval *variable_ptr;
53800
77
  zval *dim;
53801
77
  zend_refcounted *garbage = NULL;
53802
53803
77
  SAVE_OPLINE();
53804
77
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53805
53806
77
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53807
20
try_assign_dim_array:
53808
20
    SEPARATE_ARRAY(object_ptr);
53809
20
    if (IS_CV == IS_UNUSED) {
53810
0
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53811
0
      if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53812
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
53813
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53814
0
          GC_ADDREF(ht);
53815
0
        }
53816
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53817
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53818
0
          zend_array_destroy(ht);
53819
0
          goto assign_dim_error;
53820
0
        }
53821
0
      }
53822
0
      if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
53823
0
        ZVAL_DEREF(value);
53824
0
      }
53825
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53826
0
      if (UNEXPECTED(value == NULL)) {
53827
0
        zend_cannot_add_element();
53828
0
        goto assign_dim_error;
53829
0
      } else if (IS_VAR == IS_CV) {
53830
0
        if (Z_REFCOUNTED_P(value)) {
53831
0
          Z_ADDREF_P(value);
53832
0
        }
53833
0
      } else if (IS_VAR == IS_VAR) {
53834
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
53835
0
        if (Z_ISREF_P(free_op_data)) {
53836
0
          if (Z_REFCOUNTED_P(value)) {
53837
0
            Z_ADDREF_P(value);
53838
0
          }
53839
0
          zval_ptr_dtor_nogc(free_op_data);
53840
0
        }
53841
0
      } else if (IS_VAR == IS_CONST) {
53842
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53843
0
          Z_ADDREF_P(value);
53844
0
        }
53845
0
      }
53846
20
    } else {
53847
20
      dim = EX_VAR(opline->op2.var);
53848
20
      if (IS_CV == IS_CONST) {
53849
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53850
20
      } else {
53851
20
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53852
20
      }
53853
20
      if (UNEXPECTED(variable_ptr == NULL)) {
53854
5
        goto assign_dim_error;
53855
5
      }
53856
15
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53857
15
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
53858
15
    }
53859
15
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53860
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
53861
0
    }
53862
15
    if (garbage) {
53863
0
      GC_DTOR_NO_REF(garbage);
53864
0
    }
53865
64
  } else {
53866
64
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
53867
0
      object_ptr = Z_REFVAL_P(object_ptr);
53868
0
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53869
0
        goto try_assign_dim_array;
53870
0
      }
53871
0
    }
53872
64
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53873
57
      zend_object *obj = Z_OBJ_P(object_ptr);
53874
53875
57
      GC_ADDREF(obj);
53876
57
      dim = EX_VAR(opline->op2.var);
53877
57
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53878
5
        dim = ZVAL_UNDEFINED_OP2();
53879
52
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53880
0
        dim++;
53881
0
      }
53882
53883
57
      value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53884
57
      if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53885
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53886
57
      } else if (IS_VAR & (IS_CV|IS_VAR)) {
53887
57
        ZVAL_DEREF(value);
53888
57
      }
53889
53890
57
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53891
53892
57
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53893
57
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53894
0
        zend_objects_store_del(obj);
53895
0
      }
53896
57
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53897
0
      if (IS_CV == IS_UNUSED) {
53898
0
        zend_use_new_element_for_string();
53899
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53900
0
        UNDEF_RESULT();
53901
0
      } else {
53902
0
        dim = EX_VAR(opline->op2.var);
53903
0
        value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53904
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53905
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53906
0
      }
53907
7
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53908
7
      if (Z_ISREF_P(orig_object_ptr)
53909
7
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53910
7
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53911
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53912
0
        zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53913
0
        UNDEF_RESULT();
53914
7
      } else {
53915
7
        HashTable *ht = zend_new_array(8);
53916
7
        uint8_t old_type = Z_TYPE_P(object_ptr);
53917
53918
7
        ZVAL_ARR(object_ptr, ht);
53919
7
        if (UNEXPECTED(old_type == IS_FALSE)) {
53920
0
          GC_ADDREF(ht);
53921
0
          zend_false_to_array_deprecated();
53922
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53923
0
            zend_array_destroy(ht);
53924
0
            goto assign_dim_error;
53925
0
          }
53926
0
        }
53927
7
        goto try_assign_dim_array;
53928
7
      }
53929
7
    } else {
53930
0
      zend_use_scalar_as_array();
53931
0
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53932
5
assign_dim_error:
53933
5
      zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53934
5
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53935
0
        ZVAL_NULL(EX_VAR(opline->result.var));
53936
0
      }
53937
5
    }
53938
64
  }
53939
77
  if (IS_CV != IS_UNUSED) {
53940
53941
77
  }
53942
53943
  /* assign_dim has two opcodes! */
53944
77
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
53945
77
}
53946
53947
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53948
1.65k
{
53949
1.65k
  USE_OPLINE
53950
1.65k
  zval *object_ptr, *orig_object_ptr;
53951
1.65k
  zval *value;
53952
1.65k
  zval *variable_ptr;
53953
1.65k
  zval *dim;
53954
1.65k
  zend_refcounted *garbage = NULL;
53955
53956
1.65k
  SAVE_OPLINE();
53957
1.65k
  orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53958
53959
1.65k
  if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53960
1.16k
try_assign_dim_array:
53961
1.16k
    SEPARATE_ARRAY(object_ptr);
53962
1.16k
    if (IS_CV == IS_UNUSED) {
53963
0
      value = EX_VAR((opline+1)->op1.var);
53964
0
      if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53965
0
        HashTable *ht = Z_ARRVAL_P(object_ptr);
53966
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53967
0
          GC_ADDREF(ht);
53968
0
        }
53969
0
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53970
0
        if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53971
0
          zend_array_destroy(ht);
53972
0
          goto assign_dim_error;
53973
0
        }
53974
0
      }
53975
0
      if (IS_CV == IS_CV || IS_CV == IS_VAR) {
53976
0
        ZVAL_DEREF(value);
53977
0
      }
53978
0
      value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53979
0
      if (UNEXPECTED(value == NULL)) {
53980
0
        zend_cannot_add_element();
53981
0
        goto assign_dim_error;
53982
0
      } else if (IS_CV == IS_CV) {
53983
0
        if (Z_REFCOUNTED_P(value)) {
53984
0
          Z_ADDREF_P(value);
53985
0
        }
53986
0
      } else if (IS_CV == IS_VAR) {
53987
0
        zval *free_op_data = EX_VAR((opline+1)->op1.var);
53988
0
        if (Z_ISREF_P(free_op_data)) {
53989
0
          if (Z_REFCOUNTED_P(value)) {
53990
0
            Z_ADDREF_P(value);
53991
0
          }
53992
0
          zval_ptr_dtor_nogc(free_op_data);
53993
0
        }
53994
0
      } else if (IS_CV == IS_CONST) {
53995
0
        if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53996
0
          Z_ADDREF_P(value);
53997
0
        }
53998
0
      }
53999
1.16k
    } else {
54000
1.16k
      dim = EX_VAR(opline->op2.var);
54001
1.16k
      if (IS_CV == IS_CONST) {
54002
0
        variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
54003
1.16k
      } else {
54004
1.16k
        variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
54005
1.16k
      }
54006
1.16k
      if (UNEXPECTED(variable_ptr == NULL)) {
54007
0
        goto assign_dim_error;
54008
0
      }
54009
1.16k
      value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
54010
1.16k
      value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54011
1.16k
    }
54012
1.16k
    if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54013
115
      ZVAL_COPY(EX_VAR(opline->result.var), value);
54014
115
    }
54015
1.16k
    if (garbage) {
54016
32
      GC_DTOR_NO_REF(garbage);
54017
32
    }
54018
1.16k
  } else {
54019
785
    if (EXPECTED(Z_ISREF_P(object_ptr))) {
54020
300
      object_ptr = Z_REFVAL_P(object_ptr);
54021
300
      if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
54022
250
        goto try_assign_dim_array;
54023
250
      }
54024
300
    }
54025
535
    if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
54026
481
      zend_object *obj = Z_OBJ_P(object_ptr);
54027
54028
481
      GC_ADDREF(obj);
54029
481
      dim = EX_VAR(opline->op2.var);
54030
481
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
54031
2
        dim = ZVAL_UNDEFINED_OP2();
54032
479
      } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
54033
0
        dim++;
54034
0
      }
54035
54036
481
      value = EX_VAR((opline+1)->op1.var);
54037
481
      if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
54038
15
        value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
54039
466
      } else if (IS_CV & (IS_CV|IS_VAR)) {
54040
466
        ZVAL_DEREF(value);
54041
466
      }
54042
54043
481
      zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
54044
54045
481
      if (UNEXPECTED(GC_DELREF(obj) == 0)) {
54046
0
        zend_objects_store_del(obj);
54047
0
      }
54048
481
    } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
54049
0
      if (IS_CV == IS_UNUSED) {
54050
0
        zend_use_new_element_for_string();
54051
54052
0
        UNDEF_RESULT();
54053
0
      } else {
54054
0
        dim = EX_VAR(opline->op2.var);
54055
0
        value = EX_VAR((opline+1)->op1.var);
54056
0
        zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
54057
54058
0
      }
54059
54
    } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
54060
46
      if (Z_ISREF_P(orig_object_ptr)
54061
46
       && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
54062
46
       && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
54063
0
        dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54064
54065
0
        UNDEF_RESULT();
54066
46
      } else {
54067
46
        HashTable *ht = zend_new_array(8);
54068
46
        uint8_t old_type = Z_TYPE_P(object_ptr);
54069
54070
46
        ZVAL_ARR(object_ptr, ht);
54071
46
        if (UNEXPECTED(old_type == IS_FALSE)) {
54072
0
          GC_ADDREF(ht);
54073
0
          zend_false_to_array_deprecated();
54074
0
          if (UNEXPECTED(GC_DELREF(ht) == 0)) {
54075
0
            zend_array_destroy(ht);
54076
0
            goto assign_dim_error;
54077
0
          }
54078
0
        }
54079
46
        goto try_assign_dim_array;
54080
46
      }
54081
46
    } else {
54082
8
      zend_use_scalar_as_array();
54083
8
      dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54084
8
assign_dim_error:
54085
54086
8
      if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54087
6
        ZVAL_NULL(EX_VAR(opline->result.var));
54088
6
      }
54089
8
    }
54090
535
  }
54091
1.65k
  if (IS_CV != IS_UNUSED) {
54092
54093
1.65k
  }
54094
54095
  /* assign_dim has two opcodes! */
54096
1.65k
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
54097
1.65k
}
54098
54099
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54100
16.9k
{
54101
16.9k
  USE_OPLINE
54102
16.9k
  zval *value;
54103
16.9k
  zval *variable_ptr;
54104
54105
16.9k
  SAVE_OPLINE();
54106
16.9k
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54107
16.9k
  variable_ptr = EX_VAR(opline->op1.var);
54108
54109
16.9k
  if (0 || UNEXPECTED(0)) {
54110
0
    zend_refcounted *garbage = NULL;
54111
54112
0
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54113
0
    if (UNEXPECTED(0)) {
54114
0
      ZVAL_COPY(EX_VAR(opline->result.var), value);
54115
0
    }
54116
0
    if (garbage) {
54117
0
      GC_DTOR_NO_REF(garbage);
54118
0
    }
54119
16.9k
  } else {
54120
16.9k
    value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
54121
16.9k
  }
54122
54123
  /* zend_assign_to_variable() always takes care of op2, never free it! */
54124
54125
16.9k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54126
16.9k
}
54127
54128
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54129
14.5k
{
54130
14.5k
  USE_OPLINE
54131
14.5k
  zval *value;
54132
14.5k
  zval *variable_ptr;
54133
54134
14.5k
  SAVE_OPLINE();
54135
14.5k
  value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54136
14.5k
  variable_ptr = EX_VAR(opline->op1.var);
54137
54138
14.5k
  if (0 || UNEXPECTED(1)) {
54139
14.5k
    zend_refcounted *garbage = NULL;
54140
54141
14.5k
    value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54142
14.5k
    if (UNEXPECTED(1)) {
54143
14.5k
      ZVAL_COPY(EX_VAR(opline->result.var), value);
54144
14.5k
    }
54145
14.5k
    if (garbage) {
54146
2.14k
      GC_DTOR_NO_REF(garbage);
54147
2.14k
    }
54148
14.5k
  } else {
54149
0
    value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
54150
0
  }
54151
54152
  /* zend_assign_to_variable() always takes care of op2, never free it! */
54153
54154
14.5k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54155
14.5k
}
54156
54157
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54158
5.24k
{
54159
5.24k
  USE_OPLINE
54160
5.24k
  zval *variable_ptr;
54161
5.24k
  zval *value_ptr;
54162
5.24k
  zend_refcounted *garbage = NULL;
54163
54164
5.24k
  SAVE_OPLINE();
54165
5.24k
  value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
54166
5.24k
  variable_ptr = EX_VAR(opline->op1.var);
54167
54168
5.24k
  if (IS_CV == IS_VAR &&
54169
5.24k
             UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
54170
54171
0
    zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
54172
0
    variable_ptr = &EG(uninitialized_zval);
54173
5.24k
  } else if (IS_CV == IS_VAR &&
54174
5.24k
             opline->extended_value == ZEND_RETURNS_FUNCTION &&
54175
5.24k
         UNEXPECTED(!Z_ISREF_P(value_ptr))) {
54176
54177
0
    variable_ptr = zend_wrong_assign_to_variable_reference(
54178
0
      variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
54179
5.24k
  } else {
54180
5.24k
    zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
54181
5.24k
  }
54182
54183
5.24k
  if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54184
3.17k
    ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
54185
3.17k
  }
54186
54187
5.24k
  if (garbage) {
54188
2.31k
    GC_DTOR(garbage);
54189
2.31k
  }
54190
54191
54192
5.24k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54193
5.24k
}
54194
54195
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54196
605
{
54197
605
  USE_OPLINE
54198
605
  zval *property, *container, *value_ptr;
54199
54200
605
  SAVE_OPLINE();
54201
54202
605
  container = EX_VAR(opline->op1.var);
54203
605
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54204
54205
605
  value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
54206
54207
605
  if (1) {
54208
605
    if (IS_CV == IS_UNUSED) {
54209
0
      if (IS_CV == IS_CONST) {
54210
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54211
0
      } else {
54212
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54213
0
      }
54214
605
    } else {
54215
605
      if (IS_CV == IS_CONST) {
54216
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54217
605
      } else {
54218
605
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54219
605
      }
54220
605
    }
54221
605
  } else {
54222
0
    zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54223
0
  }
54224
54225
54226
605
  zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
54227
605
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
54228
605
}
54229
54230
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
54231
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54232
61
{
54233
61
  USE_OPLINE
54234
61
  zval *property, *container, *value_ptr;
54235
54236
61
  SAVE_OPLINE();
54237
54238
61
  container = EX_VAR(opline->op1.var);
54239
61
  property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54240
54241
61
  value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
54242
54243
61
  if (1) {
54244
61
    if (IS_CV == IS_UNUSED) {
54245
0
      if (IS_CV == IS_CONST) {
54246
0
        zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54247
0
      } else {
54248
0
        zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54249
0
      }
54250
61
    } else {
54251
61
      if (IS_CV == IS_CONST) {
54252
0
        zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54253
61
      } else {
54254
61
        zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54255
61
      }
54256
61
    }
54257
61
  } else {
54258
0
    zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54259
0
  }
54260
54261
54262
54263
61
  ZEND_VM_NEXT_OPCODE_EX(1, 2);
54264
61
}
54265
54266
/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
54267
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54268
367
{
54269
367
  USE_OPLINE
54270
367
  zval *op1, *op2;
54271
367
  zend_string *op1_str, *op2_str, *str;
54272
54273
54274
367
  op1 = EX_VAR(opline->op1.var);
54275
367
  op2 = EX_VAR(opline->op2.var);
54276
367
  if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
54277
367
      (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
54278
0
    zend_string *op1_str = Z_STR_P(op1);
54279
0
    zend_string *op2_str = Z_STR_P(op2);
54280
0
    zend_string *str;
54281
0
    uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
54282
54283
0
    if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
54284
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
54285
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
54286
0
      } else {
54287
0
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
54288
0
      }
54289
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54290
0
        zend_string_release_ex(op1_str, 0);
54291
0
      }
54292
0
    } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
54293
0
      if (IS_CV == IS_CONST || IS_CV == IS_CV) {
54294
0
        ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
54295
0
      } else {
54296
0
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
54297
0
      }
54298
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54299
0
        zend_string_release_ex(op2_str, 0);
54300
0
      }
54301
0
    } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
54302
0
        !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
54303
0
      size_t len = ZSTR_LEN(op1_str);
54304
54305
0
      str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
54306
0
      memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54307
0
      GC_ADD_FLAGS(str, flags);
54308
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54309
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54310
0
        zend_string_release_ex(op2_str, 0);
54311
0
      }
54312
0
    } else {
54313
0
      str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
54314
0
      memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
54315
0
      memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54316
0
      GC_ADD_FLAGS(str, flags);
54317
0
      ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54318
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54319
0
        zend_string_release_ex(op1_str, 0);
54320
0
      }
54321
0
      if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54322
0
        zend_string_release_ex(op2_str, 0);
54323
0
      }
54324
0
    }
54325
0
    ZEND_VM_NEXT_OPCODE();
54326
0
  }
54327
54328
367
  SAVE_OPLINE();
54329
367
  if (IS_CV == IS_CONST) {
54330
0
    op1_str = Z_STR_P(op1);
54331
367
  } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
54332
12
    op1_str = zend_string_copy(Z_STR_P(op1));
54333
355
  } else {
54334
355
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
54335
339
      ZVAL_UNDEFINED_OP1();
54336
339
    }
54337
355
    op1_str = zval_get_string_func(op1);
54338
355
  }
54339
367
  if (IS_CV == IS_CONST) {
54340
0
    op2_str = Z_STR_P(op2);
54341
367
  } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
54342
211
    op2_str = zend_string_copy(Z_STR_P(op2));
54343
211
  } else {
54344
156
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
54345
141
      ZVAL_UNDEFINED_OP2();
54346
141
    }
54347
156
    op2_str = zval_get_string_func(op2);
54348
156
  }
54349
367
  do {
54350
367
    if (IS_CV != IS_CONST) {
54351
367
      if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
54352
351
        if (IS_CV == IS_CONST) {
54353
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
54354
0
            GC_ADDREF(op2_str);
54355
0
          }
54356
0
        }
54357
351
        ZVAL_STR(EX_VAR(opline->result.var), op2_str);
54358
351
        zend_string_release_ex(op1_str, 0);
54359
351
        break;
54360
351
      }
54361
367
    }
54362
16
    if (IS_CV != IS_CONST) {
54363
16
      if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
54364
16
        if (IS_CV == IS_CONST) {
54365
0
          if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
54366
0
            GC_ADDREF(op1_str);
54367
0
          }
54368
0
        }
54369
16
        ZVAL_STR(EX_VAR(opline->result.var), op1_str);
54370
16
        zend_string_release_ex(op2_str, 0);
54371
16
        break;
54372
16
      }
54373
16
    }
54374
0
    str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
54375
0
    memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
54376
0
    memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54377
54378
0
    ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
54379
0
    ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54380
0
    if (IS_CV != IS_CONST) {
54381
0
      zend_string_release_ex(op1_str, 0);
54382
0
    }
54383
0
    if (IS_CV != IS_CONST) {
54384
0
      zend_string_release_ex(op2_str, 0);
54385
0
    }
54386
0
  } while (0);
54387
54388
54389
367
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54390
367
}
54391
54392
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54393
383
{
54394
383
  USE_OPLINE
54395
383
  zval *function_name;
54396
383
  zval *object;
54397
383
  zend_function *fbc;
54398
383
  zend_class_entry *called_scope;
54399
383
  zend_object *obj;
54400
383
  zend_execute_data *call;
54401
383
  uint32_t call_info;
54402
54403
383
  SAVE_OPLINE();
54404
54405
383
  object = EX_VAR(opline->op1.var);
54406
54407
383
  if (IS_CV != IS_CONST) {
54408
383
    function_name = EX_VAR(opline->op2.var);
54409
383
  }
54410
54411
383
  if (IS_CV != IS_CONST &&
54412
383
      UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
54413
15
    do {
54414
15
      if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
54415
10
        function_name = Z_REFVAL_P(function_name);
54416
10
        if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
54417
8
          break;
54418
8
        }
54419
10
      } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
54420
0
        ZVAL_UNDEFINED_OP2();
54421
0
        if (UNEXPECTED(EG(exception) != NULL)) {
54422
54423
0
          HANDLE_EXCEPTION();
54424
0
        }
54425
0
      }
54426
7
      zend_throw_error(NULL, "Method name must be a string");
54427
54428
54429
7
      HANDLE_EXCEPTION();
54430
7
    } while (0);
54431
15
  }
54432
54433
376
  if (IS_CV == IS_UNUSED) {
54434
0
    obj = Z_OBJ_P(object);
54435
376
  } else {
54436
376
    do {
54437
376
      if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
54438
365
        obj = Z_OBJ_P(object);
54439
365
      } else {
54440
11
        if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
54441
8
          zend_reference *ref = Z_REF_P(object);
54442
54443
8
          object = &ref->val;
54444
8
          if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
54445
8
            obj = Z_OBJ_P(object);
54446
8
            if (IS_CV & IS_VAR) {
54447
0
              if (UNEXPECTED(GC_DELREF(ref) == 0)) {
54448
0
                efree_size(ref, sizeof(zend_reference));
54449
0
              } else {
54450
0
                Z_ADDREF_P(object);
54451
0
              }
54452
0
            }
54453
8
            break;
54454
8
          }
54455
8
        }
54456
3
        if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
54457
3
          object = ZVAL_UNDEFINED_OP1();
54458
3
          if (UNEXPECTED(EG(exception) != NULL)) {
54459
0
            if (IS_CV != IS_CONST) {
54460
54461
0
            }
54462
0
            HANDLE_EXCEPTION();
54463
0
          }
54464
3
        }
54465
3
        if (IS_CV == IS_CONST) {
54466
0
          function_name = EX_VAR(opline->op2.var);
54467
0
        }
54468
3
        zend_invalid_method_call(object, function_name);
54469
54470
54471
3
        HANDLE_EXCEPTION();
54472
3
      }
54473
376
    } while (0);
54474
376
  }
54475
54476
373
  called_scope = obj->ce;
54477
54478
373
  if (IS_CV == IS_CONST &&
54479
373
      EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
54480
0
    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
54481
373
  } else {
54482
373
    zend_object *orig_obj = obj;
54483
54484
373
    if (IS_CV == IS_CONST) {
54485
0
      function_name = EX_VAR(opline->op2.var);
54486
0
    }
54487
54488
    /* First, locate the function. */
54489
373
    fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
54490
373
    if (UNEXPECTED(fbc == NULL)) {
54491
21
      if (EXPECTED(!EG(exception))) {
54492
21
        zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
54493
21
      }
54494
54495
21
      if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
54496
0
        zend_objects_store_del(orig_obj);
54497
0
      }
54498
21
      HANDLE_EXCEPTION();
54499
21
    }
54500
352
    if (IS_CV == IS_CONST &&
54501
352
        EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
54502
352
        EXPECTED(obj == orig_obj)) {
54503
0
      CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
54504
0
    }
54505
352
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
54506
0
      GC_ADDREF(obj); /* For $this pointer */
54507
0
      if (GC_DELREF(orig_obj) == 0) {
54508
0
        zend_objects_store_del(orig_obj);
54509
0
      }
54510
0
    }
54511
352
    if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
54512
157
      init_func_run_time_cache(&fbc->op_array);
54513
157
    }
54514
352
  }
54515
54516
352
  if (IS_CV != IS_CONST) {
54517
54518
352
  }
54519
54520
352
  call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
54521
352
  if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
54522
0
    if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
54523
0
      zend_objects_store_del(obj);
54524
0
      if (UNEXPECTED(EG(exception))) {
54525
0
        HANDLE_EXCEPTION();
54526
0
      }
54527
0
    }
54528
    /* call static method */
54529
0
    obj = (zend_object*)called_scope;
54530
0
    call_info = ZEND_CALL_NESTED_FUNCTION;
54531
352
  } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
54532
352
    if (IS_CV == IS_CV) {
54533
352
      GC_ADDREF(obj); /* For $this pointer */
54534
352
    }
54535
    /* CV may be changed indirectly (e.g. when it's a reference) */
54536
352
    call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
54537
352
  }
54538
54539
352
  call = zend_vm_stack_push_call_frame(call_info,
54540
352
    fbc, opline->extended_value, obj);
54541
352
  call->prev_execute_data = EX(call);
54542
352
  EX(call) = call;
54543
54544
352
  ZEND_VM_NEXT_OPCODE();
54545
352
}
54546
54547
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54548
0
{
54549
0
  USE_OPLINE
54550
0
  zval *expr_ptr, new_expr;
54551
54552
0
  SAVE_OPLINE();
54553
0
  if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
54554
0
      UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
54555
0
    expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
54556
0
    if (Z_ISREF_P(expr_ptr)) {
54557
0
      Z_ADDREF_P(expr_ptr);
54558
0
    } else {
54559
0
      ZVAL_MAKE_REF_EX(expr_ptr, 2);
54560
0
    }
54561
54562
0
  } else {
54563
0
    expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54564
0
    if (IS_CV == IS_TMP_VAR) {
54565
      /* pass */
54566
0
    } else if (IS_CV == IS_CONST) {
54567
0
      Z_TRY_ADDREF_P(expr_ptr);
54568
0
    } else if (IS_CV == IS_CV) {
54569
0
      ZVAL_DEREF(expr_ptr);
54570
0
      Z_TRY_ADDREF_P(expr_ptr);
54571
0
    } else /* if (IS_CV == IS_VAR) */ {
54572
0
      if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
54573
0
        zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
54574
54575
0
        expr_ptr = Z_REFVAL_P(expr_ptr);
54576
0
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
54577
0
          ZVAL_COPY_VALUE(&new_expr, expr_ptr);
54578
0
          expr_ptr = &new_expr;
54579
0
          efree_size(ref, sizeof(zend_reference));
54580
0
        } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
54581
0
          Z_ADDREF_P(expr_ptr);
54582
0
        }
54583
0
      }
54584
0
    }
54585
0
  }
54586
54587
0
  if (IS_CV != IS_UNUSED) {
54588
0
    zval *offset = EX_VAR(opline->op2.var);
54589
0
    zend_string *str;
54590
0
    zend_ulong hval;
54591
54592
0
add_again:
54593
0
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54594
0
      str = Z_STR_P(offset);
54595
0
      if (IS_CV != IS_CONST) {
54596
0
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
54597
0
          goto num_index;
54598
0
        }
54599
0
      }
54600
0
str_index:
54601
0
      zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
54602
0
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54603
0
      hval = Z_LVAL_P(offset);
54604
0
num_index:
54605
0
      zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
54606
0
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
54607
0
      offset = Z_REFVAL_P(offset);
54608
0
      goto add_again;
54609
0
    } else if (Z_TYPE_P(offset) == IS_NULL) {
54610
0
      str = ZSTR_EMPTY_ALLOC();
54611
0
      goto str_index;
54612
0
    } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
54613
0
      hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
54614
0
      goto num_index;
54615
0
    } else if (Z_TYPE_P(offset) == IS_FALSE) {
54616
0
      hval = 0;
54617
0
      goto num_index;
54618
0
    } else if (Z_TYPE_P(offset) == IS_TRUE) {
54619
0
      hval = 1;
54620
0
      goto num_index;
54621
0
    } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
54622
0
      zend_use_resource_as_offset(offset);
54623
0
      hval = Z_RES_HANDLE_P(offset);
54624
0
      goto num_index;
54625
0
    } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
54626
0
      ZVAL_UNDEFINED_OP2();
54627
0
      str = ZSTR_EMPTY_ALLOC();
54628
0
      goto str_index;
54629
0
    } else {
54630
0
      zend_illegal_array_offset_access(offset);
54631
0
      zval_ptr_dtor_nogc(expr_ptr);
54632
0
    }
54633
54634
0
  } else {
54635
0
    if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
54636
0
      zend_cannot_add_element();
54637
0
      zval_ptr_dtor_nogc(expr_ptr);
54638
0
    }
54639
0
  }
54640
0
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54641
0
}
54642
54643
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54644
0
{
54645
0
  zval *array;
54646
0
  uint32_t size;
54647
0
  USE_OPLINE
54648
54649
0
  SAVE_OPLINE();
54650
0
  array = EX_VAR(opline->result.var);
54651
0
  if (IS_CV != IS_UNUSED) {
54652
0
    size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
54653
0
    ZVAL_ARR(array, zend_new_array(size));
54654
    /* Explicitly initialize array as not-packed if flag is set */
54655
0
    if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
54656
0
      zend_hash_real_init_mixed(Z_ARRVAL_P(array));
54657
0
    }
54658
0
    ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
54659
0
  } else {
54660
0
    ZVAL_ARR(array, zend_new_array(0));
54661
0
    ZEND_VM_NEXT_OPCODE();
54662
0
  }
54663
0
}
54664
54665
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54666
1.48k
{
54667
1.48k
  USE_OPLINE
54668
1.48k
  zval *container;
54669
1.48k
  zval *offset;
54670
1.48k
  zend_ulong hval;
54671
1.48k
  zend_string *key;
54672
54673
1.48k
  SAVE_OPLINE();
54674
1.48k
  container = EX_VAR(opline->op1.var);
54675
1.48k
  offset = EX_VAR(opline->op2.var);
54676
54677
1.48k
  do {
54678
1.48k
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54679
103
      HashTable *ht;
54680
54681
739
unset_dim_array:
54682
739
      SEPARATE_ARRAY(container);
54683
739
      ht = Z_ARRVAL_P(container);
54684
739
offset_again:
54685
739
      if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54686
184
        key = Z_STR_P(offset);
54687
184
        if (IS_CV != IS_CONST) {
54688
184
          if (ZEND_HANDLE_NUMERIC(key, hval)) {
54689
9
            goto num_index_dim;
54690
9
          }
54691
184
        }
54692
209
str_index_dim:
54693
209
        ZEND_ASSERT(ht != &EG(symbol_table));
54694
209
        zend_hash_del(ht, key);
54695
555
      } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54696
506
        hval = Z_LVAL_P(offset);
54697
530
num_index_dim:
54698
530
        zend_hash_index_del(ht, hval);
54699
530
      } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
54700
0
        offset = Z_REFVAL_P(offset);
54701
0
        goto offset_again;
54702
49
      } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
54703
13
        hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
54704
13
        goto num_index_dim;
54705
36
      } else if (Z_TYPE_P(offset) == IS_NULL) {
54706
12
        key = ZSTR_EMPTY_ALLOC();
54707
12
        goto str_index_dim;
54708
24
      } else if (Z_TYPE_P(offset) == IS_FALSE) {
54709
2
        hval = 0;
54710
2
        goto num_index_dim;
54711
22
      } else if (Z_TYPE_P(offset) == IS_TRUE) {
54712
0
        hval = 1;
54713
0
        goto num_index_dim;
54714
22
      } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
54715
0
        zend_use_resource_as_offset(offset);
54716
0
        hval = Z_RES_HANDLE_P(offset);
54717
0
        goto num_index_dim;
54718
22
      } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
54719
22
        ZVAL_UNDEFINED_OP2();
54720
22
        key = ZSTR_EMPTY_ALLOC();
54721
22
        goto str_index_dim;
54722
22
      } else {
54723
0
        zend_illegal_array_offset_unset(offset);
54724
0
      }
54725
739
      break;
54726
1.37k
    } else if (Z_ISREF_P(container)) {
54727
638
      container = Z_REFVAL_P(container);
54728
638
      if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54729
636
        goto unset_dim_array;
54730
636
      }
54731
638
    }
54732
742
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
54733
717
      container = ZVAL_UNDEFINED_OP1();
54734
717
    }
54735
742
    if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
54736
250
      offset = ZVAL_UNDEFINED_OP2();
54737
250
    }
54738
742
    if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
54739
23
      if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
54740
0
        offset++;
54741
0
      }
54742
23
      Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
54743
719
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
54744
2
      zend_throw_error(NULL, "Cannot unset string offsets");
54745
717
    } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
54746
0
      zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
54747
717
    } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
54748
0
      zend_false_to_array_deprecated();
54749
0
    }
54750
742
  } while (0);
54751
54752
54753
1.48k
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54754
1.48k
}
54755
54756
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54757
17
{
54758
17
  USE_OPLINE
54759
17
  zval *container;
54760
17
  zval *offset;
54761
17
  zend_string *name, *tmp_name;
54762
54763
17
  SAVE_OPLINE();
54764
17
  container = EX_VAR(opline->op1.var);
54765
17
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54766
54767
17
  do {
54768
17
    if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
54769
0
      if (Z_ISREF_P(container)) {
54770
0
        container = Z_REFVAL_P(container);
54771
0
        if (Z_TYPE_P(container) != IS_OBJECT) {
54772
0
          if (IS_CV == IS_CV
54773
0
           && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
54774
0
            ZVAL_UNDEFINED_OP1();
54775
0
          }
54776
0
          break;
54777
0
        }
54778
0
      } else {
54779
0
        break;
54780
0
      }
54781
0
    }
54782
17
    if (IS_CV == IS_CONST) {
54783
0
      name = Z_STR_P(offset);
54784
17
    } else {
54785
17
      name = zval_try_get_tmp_string(offset, &tmp_name);
54786
17
      if (UNEXPECTED(!name)) {
54787
0
        break;
54788
0
      }
54789
17
    }
54790
17
    Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
54791
17
    if (IS_CV != IS_CONST) {
54792
17
      zend_tmp_string_release(tmp_name);
54793
17
    }
54794
17
  } while (0);
54795
54796
54797
17
  ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54798
17
}
54799
54800
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54801
1.22k
{
54802
1.22k
  USE_OPLINE
54803
1.22k
  zval *container;
54804
1.22k
  bool result;
54805
1.22k
  zend_ulong hval;
54806
1.22k
  zval *offset;
54807
54808
1.22k
  SAVE_OPLINE();
54809
1.22k
  container = EX_VAR(opline->op1.var);
54810
1.22k
  offset = EX_VAR(opline->op2.var);
54811
54812
1.22k
  if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54813
581
    HashTable *ht;
54814
581
    zval *value;
54815
581
    zend_string *str;
54816
54817
770
isset_dim_obj_array:
54818
770
    ht = Z_ARRVAL_P(container);
54819
770
isset_again:
54820
770
    if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54821
200
      str = Z_STR_P(offset);
54822
200
      if (IS_CV != IS_CONST) {
54823
200
        if (ZEND_HANDLE_NUMERIC(str, hval)) {
54824
0
          goto num_index_prop;
54825
0
        }
54826
200
      }
54827
200
      value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
54828
570
    } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54829
564
      hval = Z_LVAL_P(offset);
54830
564
num_index_prop:
54831
564
      value = zend_hash_index_find(ht, hval);
54832
564
    } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
54833
0
      offset = Z_REFVAL_P(offset);
54834
0
      goto isset_again;
54835
6
    } else {
54836
6
      value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
54837
6
      if (UNEXPECTED(EG(exception))) {
54838
0
        result = 0;
54839
0
        goto isset_dim_obj_exit;
54840
0
      }
54841
6
    }
54842
54843
770
    if (!(opline->extended_value & ZEND_ISEMPTY)) {
54844
      /* > IS_NULL means not IS_UNDEF and not IS_NULL */
54845
770
      result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
54846
770
          (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
54847
54848
770
      if (IS_CV & (IS_CONST|IS_CV)) {
54849
        /* avoid exception check */
54850
54851
770
        ZEND_VM_SMART_BRANCH(result, 0);
54852
770
      }
54853
770
    } else {
54854
0
      result = (value == NULL || !i_zend_is_true(value));
54855
0
    }
54856
0
    goto isset_dim_obj_exit;
54857
770
  } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
54858
189
    container = Z_REFVAL_P(container);
54859
189
    if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54860
189
      goto isset_dim_obj_array;
54861
189
    }
54862
189
  }
54863
54864
454
  if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
54865
0
    offset++;
54866
0
  }
54867
454
  if (!(opline->extended_value & ZEND_ISEMPTY)) {
54868
337
    result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
54869
337
  } else {
54870
117
    result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
54871
117
  }
54872
54873
454
isset_dim_obj_exit:
54874
54875
54876
454
  ZEND_VM_SMART_BRANCH(result, 1);
54877
454
}
54878
54879
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54880
25
{
54881
25
  USE_OPLINE
54882
25
  zval *container;
54883
25
  int result;
54884
25
  zval *offset;
54885
25
  zend_string *name, *tmp_name;
54886
54887
25
  SAVE_OPLINE();
54888
25
  container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
54889
25
  offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54890
54891
25
  if (IS_CV == IS_CONST ||
54892
25
      (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
54893
10
    if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
54894
5
      container = Z_REFVAL_P(container);
54895
5
      if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
54896
0
        result = (opline->extended_value & ZEND_ISEMPTY);
54897
0
        goto isset_object_finish;
54898
0
      }
54899
5
    } else {
54900
5
      result = (opline->extended_value & ZEND_ISEMPTY);
54901
5
      goto isset_object_finish;
54902
5
    }
54903
10
  }
54904
54905
20
  if (IS_CV == IS_CONST) {
54906
0
    name = Z_STR_P(offset);
54907
20
  } else {
54908
20
    name = zval_try_get_tmp_string(offset, &tmp_name);
54909
20
    if (UNEXPECTED(!name)) {
54910
0
      result = 0;
54911
0
      goto isset_object_finish;
54912
0
    }
54913
20
  }
54914
54915
20
  result =
54916
20
    (opline->extended_value & ZEND_ISEMPTY) ^
54917
20
    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));
54918
54919
20
  if (IS_CV != IS_CONST) {
54920
20
    zend_tmp_string_release(tmp_name);
54921
20
  }
54922
54923
25
isset_object_finish:
54924
54925
54926
25
  ZEND_VM_SMART_BRANCH(result, 1);
54927
25
}
54928
54929
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54930
2
{
54931
2
  USE_OPLINE
54932
54933
2
  zval *key, *subject;
54934
2
  HashTable *ht;
54935
2
  bool result;
54936
54937
2
  SAVE_OPLINE();
54938
54939
2
  key = EX_VAR(opline->op1.var);
54940
2
  subject = EX_VAR(opline->op2.var);
54941
54942
2
  if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
54943
0
array_key_exists_array:
54944
0
    ht = Z_ARRVAL_P(subject);
54945
0
    result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
54946
2
  } else {
54947
2
    if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
54948
0
      subject = Z_REFVAL_P(subject);
54949
0
      if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
54950
0
        goto array_key_exists_array;
54951
0
      }
54952
0
    }
54953
2
    zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
54954
2
    result = 0;
54955
2
  }
54956
54957
54958
2
  ZEND_VM_SMART_BRANCH(result, 1);
54959
2
}
54960
54961
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54962
97
{
54963
97
  USE_OPLINE
54964
54965
97
  zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
54966
54967
97
  SAVE_OPLINE();
54968
97
  if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
54969
0
    ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
54970
0
  }
54971
54972
  /* Destroy the previously yielded value */
54973
97
  zval_ptr_dtor(&generator->value);
54974
54975
  /* Destroy the previously yielded key */
54976
97
  zval_ptr_dtor(&generator->key);
54977
54978
  /* Set the new yielded value */
54979
97
  if (IS_CV != IS_UNUSED) {
54980
97
    if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
54981
      /* Constants and temporary variables aren't yieldable by reference,
54982
       * but we still allow them with a notice. */
54983
97
      if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
54984
0
        zval *value;
54985
54986
0
        zend_error(E_NOTICE, "Only variable references should be yielded by reference");
54987
54988
0
        value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54989
0
        ZVAL_COPY_VALUE(&generator->value, value);
54990
0
        if (IS_CV == IS_CONST) {
54991
0
          if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
54992
0
            Z_ADDREF(generator->value);
54993
0
          }
54994
0
        }
54995
97
      } else {
54996
97
        zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
54997
54998
        /* If a function call result is yielded and the function did
54999
         * not return by reference we throw a notice. */
55000
97
        do {
55001
97
          if (IS_CV == IS_VAR) {
55002
0
            ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
55003
0
            if (opline->extended_value == ZEND_RETURNS_FUNCTION
55004
0
             && !Z_ISREF_P(value_ptr)) {
55005
0
              zend_error(E_NOTICE, "Only variable references should be yielded by reference");
55006
0
              ZVAL_COPY(&generator->value, value_ptr);
55007
0
              break;
55008
0
            }
55009
0
          }
55010
97
          if (Z_ISREF_P(value_ptr)) {
55011
89
            Z_ADDREF_P(value_ptr);
55012
89
          } else {
55013
8
            ZVAL_MAKE_REF_EX(value_ptr, 2);
55014
8
          }
55015
97
          ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
55016
97
        } while (0);
55017
55018
97
      }
55019
97
    } else {
55020
0
      zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
55021
55022
      /* Consts, temporary variables and references need copying */
55023
0
      if (IS_CV == IS_CONST) {
55024
0
        ZVAL_COPY_VALUE(&generator->value, value);
55025
0
        if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
55026
0
          Z_ADDREF(generator->value);
55027
0
        }
55028
0
      } else if (IS_CV == IS_TMP_VAR) {
55029
0
        ZVAL_COPY_VALUE(&generator->value, value);
55030
0
      } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
55031
0
        ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
55032
55033
0
      } else {
55034
0
        ZVAL_COPY_VALUE(&generator->value, value);
55035
0
        if (IS_CV == IS_CV) {
55036
0
          if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
55037
0
        }
55038
0
      }
55039
0
    }
55040
97
  } else {
55041
    /* If no value was specified yield null */
55042
0
    ZVAL_NULL(&generator->value);
55043
0
  }
55044
55045
  /* Set the new yielded key */
55046
97
  if (IS_CV != IS_UNUSED) {
55047
97
    zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
55048
97
    if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
55049
0
      key = Z_REFVAL_P(key);
55050
0
    }
55051
97
    ZVAL_COPY(&generator->key, key);
55052
55053
97
    if (Z_TYPE(generator->key) == IS_LONG
55054
97
        && Z_LVAL(generator->key) > generator->largest_used_integer_key
55055
97
    ) {
55056
85
      generator->largest_used_integer_key = Z_LVAL(generator->key);
55057
85
    }
55058
97
  } else {
55059
    /* If no key was specified we use auto-increment keys */
55060
0
    generator->largest_used_integer_key++;
55061
0
    ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
55062
0
  }
55063
55064
97
  if (RETURN_VALUE_USED(opline)) {
55065
    /* If the return value of yield is used set the send
55066
     * target and initialize it to NULL */
55067
0
    generator->send_target = EX_VAR(opline->result.var);
55068
0
    ZVAL_NULL(generator->send_target);
55069
97
  } else {
55070
97
    generator->send_target = NULL;
55071
97
  }
55072
55073
  /* The GOTO VM uses a local opline variable. We need to set the opline
55074
   * variable in execute_data so we don't resume at an old position. */
55075
97
  SAVE_OPLINE();
55076
55077
97
  ZEND_VM_RETURN();
55078
97
}
55079
55080
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
55081
71
{
55082
  /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
55083
  /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
55084
  /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
55085
71
  USE_OPLINE
55086
71
  zval *op1, *op2;
55087
71
  bool result;
55088
55089
71
  op1 = EX_VAR(opline->op1.var);
55090
71
  op2 = EX_VAR(opline->op2.var);
55091
71
  result = fast_is_identical_function(op1, op2);
55092
  /* Free is a no-op for const/cv */
55093
71
  ZEND_VM_SMART_BRANCH(result, 0);
55094
71
}
55095
55096
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
55097
0
{
55098
0
  USE_OPLINE
55099
0
  zval *op1, *op2;
55100
0
  bool result;
55101
55102
0
  op1 = EX_VAR(opline->op1.var);
55103
0
  op2 = EX_VAR(opline->op2.var);
55104
0
  result = fast_is_identical_function(op1, op2);
55105
  /* Free is a no-op for const/cv */
55106
0
  ZEND_VM_SMART_BRANCH(!result, 0);
55107
0
}
55108
55109
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
55110
0
{
55111
0
  USE_OPLINE
55112
55113
0
  SAVE_OPLINE();
55114
0
  zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);
55115
0
  ZEND_VM_NEXT_OPCODE(); /* Never reached */
55116
0
}
55117
55118
55119
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
55120
# undef ZEND_VM_TAIL_CALL
55121
# undef ZEND_VM_CONTINUE
55122
# undef ZEND_VM_RETURN
55123
55124
# define ZEND_VM_TAIL_CALL(call) call; ZEND_VM_CONTINUE()
55125
# define ZEND_VM_CONTINUE()      HYBRID_NEXT()
55126
# define ZEND_VM_RETURN()        goto HYBRID_HALT_LABEL
55127
#endif
55128
55129
55130
#if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
55131
# pragma GCC push_options
55132
# pragma GCC optimize("no-gcse")
55133
# pragma GCC optimize("no-ivopts")
55134
#endif
55135
#if defined(_WIN64) && defined(_M_X64)
55136
/* See save_xmm_x86_64_ms_masm.asm */
55137
void execute_ex_real(zend_execute_data *ex)
55138
#else
55139
ZEND_API void execute_ex(zend_execute_data *ex)
55140
#endif
55141
82.6k
{
55142
82.6k
  DCL_OPLINE
55143
55144
#if defined(__GNUC__) && defined(__aarch64__)
55145
  __asm__ __volatile__ (""::: "v8","v9","v10","v11","v12","v13","v14","v15");
55146
#endif
55147
55148
#if defined(ZEND_VM_IP_GLOBAL_REG) || defined(ZEND_VM_FP_GLOBAL_REG)
55149
  struct {
55150
#ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
55151
    char hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];
55152
#endif
55153
#ifdef ZEND_VM_IP_GLOBAL_REG
55154
    const zend_op *orig_opline;
55155
#endif
55156
#ifdef ZEND_VM_FP_GLOBAL_REG
55157
    zend_execute_data *orig_execute_data;
55158
#endif
55159
  } vm_stack_data;
55160
#endif
55161
#ifdef ZEND_VM_IP_GLOBAL_REG
55162
  vm_stack_data.orig_opline = opline;
55163
#endif
55164
#ifdef ZEND_VM_FP_GLOBAL_REG
55165
  vm_stack_data.orig_execute_data = execute_data;
55166
  execute_data = ex;
55167
#else
55168
82.6k
  zend_execute_data *execute_data = ex;
55169
82.6k
#endif
55170
55171
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
55172
  if (UNEXPECTED(execute_data == NULL)) {
55173
    static const void * const labels[] = {
55174
      (void*)&&ZEND_NOP_SPEC_LABEL,
55175
      (void*)&&ZEND_ADD_SPEC_CONST_CONST_LABEL,
55176
      (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55177
      (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55178
      (void*)&&ZEND_NULL_LABEL,
55179
      (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55180
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55181
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55182
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55183
      (void*)&&ZEND_NULL_LABEL,
55184
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55185
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55186
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55187
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55188
      (void*)&&ZEND_NULL_LABEL,
55189
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55190
      (void*)&&ZEND_NULL_LABEL,
55191
      (void*)&&ZEND_NULL_LABEL,
55192
      (void*)&&ZEND_NULL_LABEL,
55193
      (void*)&&ZEND_NULL_LABEL,
55194
      (void*)&&ZEND_NULL_LABEL,
55195
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55196
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55197
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55198
      (void*)&&ZEND_NULL_LABEL,
55199
      (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55200
      (void*)&&ZEND_SUB_SPEC_CONST_CONST_LABEL,
55201
      (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55202
      (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55203
      (void*)&&ZEND_NULL_LABEL,
55204
      (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55205
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55206
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55207
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55208
      (void*)&&ZEND_NULL_LABEL,
55209
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55210
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55211
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55212
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55213
      (void*)&&ZEND_NULL_LABEL,
55214
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55215
      (void*)&&ZEND_NULL_LABEL,
55216
      (void*)&&ZEND_NULL_LABEL,
55217
      (void*)&&ZEND_NULL_LABEL,
55218
      (void*)&&ZEND_NULL_LABEL,
55219
      (void*)&&ZEND_NULL_LABEL,
55220
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55221
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55222
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55223
      (void*)&&ZEND_NULL_LABEL,
55224
      (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55225
      (void*)&&ZEND_MUL_SPEC_CONST_CONST_LABEL,
55226
      (void*)&&ZEND_NULL_LABEL,
55227
      (void*)&&ZEND_NULL_LABEL,
55228
      (void*)&&ZEND_NULL_LABEL,
55229
      (void*)&&ZEND_NULL_LABEL,
55230
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55231
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55232
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55233
      (void*)&&ZEND_NULL_LABEL,
55234
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55235
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55236
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55237
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55238
      (void*)&&ZEND_NULL_LABEL,
55239
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55240
      (void*)&&ZEND_NULL_LABEL,
55241
      (void*)&&ZEND_NULL_LABEL,
55242
      (void*)&&ZEND_NULL_LABEL,
55243
      (void*)&&ZEND_NULL_LABEL,
55244
      (void*)&&ZEND_NULL_LABEL,
55245
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55246
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55247
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55248
      (void*)&&ZEND_NULL_LABEL,
55249
      (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55250
      (void*)&&ZEND_DIV_SPEC_CONST_CONST_LABEL,
55251
      (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
55252
      (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
55253
      (void*)&&ZEND_NULL_LABEL,
55254
      (void*)&&ZEND_DIV_SPEC_CONST_CV_LABEL,
55255
      (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
55256
      (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55257
      (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55258
      (void*)&&ZEND_NULL_LABEL,
55259
      (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
55260
      (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
55261
      (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55262
      (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55263
      (void*)&&ZEND_NULL_LABEL,
55264
      (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
55265
      (void*)&&ZEND_NULL_LABEL,
55266
      (void*)&&ZEND_NULL_LABEL,
55267
      (void*)&&ZEND_NULL_LABEL,
55268
      (void*)&&ZEND_NULL_LABEL,
55269
      (void*)&&ZEND_NULL_LABEL,
55270
      (void*)&&ZEND_DIV_SPEC_CV_CONST_LABEL,
55271
      (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
55272
      (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
55273
      (void*)&&ZEND_NULL_LABEL,
55274
      (void*)&&ZEND_DIV_SPEC_CV_CV_LABEL,
55275
      (void*)&&ZEND_MOD_SPEC_CONST_CONST_LABEL,
55276
      (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55277
      (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55278
      (void*)&&ZEND_NULL_LABEL,
55279
      (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55280
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55281
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55282
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55283
      (void*)&&ZEND_NULL_LABEL,
55284
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55285
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55286
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55287
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55288
      (void*)&&ZEND_NULL_LABEL,
55289
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55290
      (void*)&&ZEND_NULL_LABEL,
55291
      (void*)&&ZEND_NULL_LABEL,
55292
      (void*)&&ZEND_NULL_LABEL,
55293
      (void*)&&ZEND_NULL_LABEL,
55294
      (void*)&&ZEND_NULL_LABEL,
55295
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55296
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55297
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55298
      (void*)&&ZEND_NULL_LABEL,
55299
      (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55300
      (void*)&&ZEND_SL_SPEC_CONST_CONST_LABEL,
55301
      (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55302
      (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55303
      (void*)&&ZEND_NULL_LABEL,
55304
      (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55305
      (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55306
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55307
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55308
      (void*)&&ZEND_NULL_LABEL,
55309
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55310
      (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55311
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55312
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55313
      (void*)&&ZEND_NULL_LABEL,
55314
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55315
      (void*)&&ZEND_NULL_LABEL,
55316
      (void*)&&ZEND_NULL_LABEL,
55317
      (void*)&&ZEND_NULL_LABEL,
55318
      (void*)&&ZEND_NULL_LABEL,
55319
      (void*)&&ZEND_NULL_LABEL,
55320
      (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55321
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55322
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55323
      (void*)&&ZEND_NULL_LABEL,
55324
      (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55325
      (void*)&&ZEND_SR_SPEC_CONST_CONST_LABEL,
55326
      (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55327
      (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55328
      (void*)&&ZEND_NULL_LABEL,
55329
      (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55330
      (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55331
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55332
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55333
      (void*)&&ZEND_NULL_LABEL,
55334
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55335
      (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55336
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55337
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55338
      (void*)&&ZEND_NULL_LABEL,
55339
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55340
      (void*)&&ZEND_NULL_LABEL,
55341
      (void*)&&ZEND_NULL_LABEL,
55342
      (void*)&&ZEND_NULL_LABEL,
55343
      (void*)&&ZEND_NULL_LABEL,
55344
      (void*)&&ZEND_NULL_LABEL,
55345
      (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55346
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55347
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55348
      (void*)&&ZEND_NULL_LABEL,
55349
      (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55350
      (void*)&&ZEND_NULL_LABEL,
55351
      (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
55352
      (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
55353
      (void*)&&ZEND_NULL_LABEL,
55354
      (void*)&&ZEND_CONCAT_SPEC_CONST_CV_LABEL,
55355
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
55356
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55357
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55358
      (void*)&&ZEND_NULL_LABEL,
55359
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
55360
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
55361
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55362
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55363
      (void*)&&ZEND_NULL_LABEL,
55364
      (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
55365
      (void*)&&ZEND_NULL_LABEL,
55366
      (void*)&&ZEND_NULL_LABEL,
55367
      (void*)&&ZEND_NULL_LABEL,
55368
      (void*)&&ZEND_NULL_LABEL,
55369
      (void*)&&ZEND_NULL_LABEL,
55370
      (void*)&&ZEND_CONCAT_SPEC_CV_CONST_LABEL,
55371
      (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
55372
      (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
55373
      (void*)&&ZEND_NULL_LABEL,
55374
      (void*)&&ZEND_CONCAT_SPEC_CV_CV_LABEL,
55375
      (void*)&&ZEND_BW_OR_SPEC_CONST_CONST_LABEL,
55376
      (void*)&&ZEND_NULL_LABEL,
55377
      (void*)&&ZEND_NULL_LABEL,
55378
      (void*)&&ZEND_NULL_LABEL,
55379
      (void*)&&ZEND_NULL_LABEL,
55380
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55381
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55382
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55383
      (void*)&&ZEND_NULL_LABEL,
55384
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55385
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55386
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55387
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55388
      (void*)&&ZEND_NULL_LABEL,
55389
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55390
      (void*)&&ZEND_NULL_LABEL,
55391
      (void*)&&ZEND_NULL_LABEL,
55392
      (void*)&&ZEND_NULL_LABEL,
55393
      (void*)&&ZEND_NULL_LABEL,
55394
      (void*)&&ZEND_NULL_LABEL,
55395
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55396
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55397
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55398
      (void*)&&ZEND_NULL_LABEL,
55399
      (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55400
      (void*)&&ZEND_BW_AND_SPEC_CONST_CONST_LABEL,
55401
      (void*)&&ZEND_NULL_LABEL,
55402
      (void*)&&ZEND_NULL_LABEL,
55403
      (void*)&&ZEND_NULL_LABEL,
55404
      (void*)&&ZEND_NULL_LABEL,
55405
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55406
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55407
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55408
      (void*)&&ZEND_NULL_LABEL,
55409
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55410
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55411
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55412
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55413
      (void*)&&ZEND_NULL_LABEL,
55414
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55415
      (void*)&&ZEND_NULL_LABEL,
55416
      (void*)&&ZEND_NULL_LABEL,
55417
      (void*)&&ZEND_NULL_LABEL,
55418
      (void*)&&ZEND_NULL_LABEL,
55419
      (void*)&&ZEND_NULL_LABEL,
55420
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55421
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55422
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55423
      (void*)&&ZEND_NULL_LABEL,
55424
      (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55425
      (void*)&&ZEND_BW_XOR_SPEC_CONST_CONST_LABEL,
55426
      (void*)&&ZEND_NULL_LABEL,
55427
      (void*)&&ZEND_NULL_LABEL,
55428
      (void*)&&ZEND_NULL_LABEL,
55429
      (void*)&&ZEND_NULL_LABEL,
55430
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55431
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55432
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55433
      (void*)&&ZEND_NULL_LABEL,
55434
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55435
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55436
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55437
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55438
      (void*)&&ZEND_NULL_LABEL,
55439
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55440
      (void*)&&ZEND_NULL_LABEL,
55441
      (void*)&&ZEND_NULL_LABEL,
55442
      (void*)&&ZEND_NULL_LABEL,
55443
      (void*)&&ZEND_NULL_LABEL,
55444
      (void*)&&ZEND_NULL_LABEL,
55445
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55446
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55447
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55448
      (void*)&&ZEND_NULL_LABEL,
55449
      (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55450
      (void*)&&ZEND_POW_SPEC_CONST_CONST_LABEL,
55451
      (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
55452
      (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
55453
      (void*)&&ZEND_NULL_LABEL,
55454
      (void*)&&ZEND_POW_SPEC_CONST_CV_LABEL,
55455
      (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
55456
      (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55457
      (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55458
      (void*)&&ZEND_NULL_LABEL,
55459
      (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
55460
      (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
55461
      (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55462
      (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55463
      (void*)&&ZEND_NULL_LABEL,
55464
      (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
55465
      (void*)&&ZEND_NULL_LABEL,
55466
      (void*)&&ZEND_NULL_LABEL,
55467
      (void*)&&ZEND_NULL_LABEL,
55468
      (void*)&&ZEND_NULL_LABEL,
55469
      (void*)&&ZEND_NULL_LABEL,
55470
      (void*)&&ZEND_POW_SPEC_CV_CONST_LABEL,
55471
      (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
55472
      (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
55473
      (void*)&&ZEND_NULL_LABEL,
55474
      (void*)&&ZEND_POW_SPEC_CV_CV_LABEL,
55475
      (void*)&&ZEND_BW_NOT_SPEC_CONST_LABEL,
55476
      (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55477
      (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55478
      (void*)&&ZEND_NULL_LABEL,
55479
      (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55480
      (void*)&&ZEND_BOOL_NOT_SPEC_CONST_LABEL,
55481
      (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
55482
      (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
55483
      (void*)&&ZEND_NULL_LABEL,
55484
      (void*)&&ZEND_BOOL_NOT_SPEC_CV_LABEL,
55485
      (void*)&&ZEND_BOOL_XOR_SPEC_CONST_CONST_LABEL,
55486
      (void*)&&ZEND_NULL_LABEL,
55487
      (void*)&&ZEND_NULL_LABEL,
55488
      (void*)&&ZEND_NULL_LABEL,
55489
      (void*)&&ZEND_NULL_LABEL,
55490
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
55491
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55492
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55493
      (void*)&&ZEND_NULL_LABEL,
55494
      (void*)&&ZEND_NULL_LABEL,
55495
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
55496
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55497
      (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55498
      (void*)&&ZEND_NULL_LABEL,
55499
      (void*)&&ZEND_NULL_LABEL,
55500
      (void*)&&ZEND_NULL_LABEL,
55501
      (void*)&&ZEND_NULL_LABEL,
55502
      (void*)&&ZEND_NULL_LABEL,
55503
      (void*)&&ZEND_NULL_LABEL,
55504
      (void*)&&ZEND_NULL_LABEL,
55505
      (void*)&&ZEND_BOOL_XOR_SPEC_CV_CONST_LABEL,
55506
      (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
55507
      (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
55508
      (void*)&&ZEND_NULL_LABEL,
55509
      (void*)&&ZEND_BOOL_XOR_SPEC_CV_CV_LABEL,
55510
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CONST_CONST_LABEL,
55511
      (void*)&&ZEND_NULL_LABEL,
55512
      (void*)&&ZEND_NULL_LABEL,
55513
      (void*)&&ZEND_NULL_LABEL,
55514
      (void*)&&ZEND_NULL_LABEL,
55515
      (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_CONST_LABEL,
55516
      (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_TMP_LABEL,
55517
      (void*)&&ZEND_NULL_LABEL,
55518
      (void*)&&ZEND_NULL_LABEL,
55519
      (void*)&&ZEND_NULL_LABEL,
55520
      (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_CONST_LABEL,
55521
      (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_TMP_LABEL,
55522
      (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_VAR_LABEL,
55523
      (void*)&&ZEND_NULL_LABEL,
55524
      (void*)&&ZEND_NULL_LABEL,
55525
      (void*)&&ZEND_NULL_LABEL,
55526
      (void*)&&ZEND_NULL_LABEL,
55527
      (void*)&&ZEND_NULL_LABEL,
55528
      (void*)&&ZEND_NULL_LABEL,
55529
      (void*)&&ZEND_NULL_LABEL,
55530
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CONST_LABEL,
55531
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_TMP_LABEL,
55532
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_VAR_LABEL,
55533
      (void*)&&ZEND_NULL_LABEL,
55534
      (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CV_LABEL,
55535
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_LABEL,
55536
      (void*)&&ZEND_NULL_LABEL,
55537
      (void*)&&ZEND_NULL_LABEL,
55538
      (void*)&&ZEND_NULL_LABEL,
55539
      (void*)&&ZEND_NULL_LABEL,
55540
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_LABEL,
55541
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_LABEL,
55542
      (void*)&&ZEND_NULL_LABEL,
55543
      (void*)&&ZEND_NULL_LABEL,
55544
      (void*)&&ZEND_NULL_LABEL,
55545
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_LABEL,
55546
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_LABEL,
55547
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_LABEL,
55548
      (void*)&&ZEND_NULL_LABEL,
55549
      (void*)&&ZEND_NULL_LABEL,
55550
      (void*)&&ZEND_NULL_LABEL,
55551
      (void*)&&ZEND_NULL_LABEL,
55552
      (void*)&&ZEND_NULL_LABEL,
55553
      (void*)&&ZEND_NULL_LABEL,
55554
      (void*)&&ZEND_NULL_LABEL,
55555
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_LABEL,
55556
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_LABEL,
55557
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_LABEL,
55558
      (void*)&&ZEND_NULL_LABEL,
55559
      (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_LABEL,
55560
      (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55561
      (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55562
      (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55563
      (void*)&&ZEND_NULL_LABEL,
55564
      (void*)&&ZEND_NULL_LABEL,
55565
      (void*)&&ZEND_NULL_LABEL,
55566
      (void*)&&ZEND_NULL_LABEL,
55567
      (void*)&&ZEND_NULL_LABEL,
55568
      (void*)&&ZEND_NULL_LABEL,
55569
      (void*)&&ZEND_NULL_LABEL,
55570
      (void*)&&ZEND_NULL_LABEL,
55571
      (void*)&&ZEND_NULL_LABEL,
55572
      (void*)&&ZEND_NULL_LABEL,
55573
      (void*)&&ZEND_NULL_LABEL,
55574
      (void*)&&ZEND_NULL_LABEL,
55575
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55576
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55577
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55578
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55579
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55580
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55581
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55582
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55583
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55584
      (void*)&&ZEND_NULL_LABEL,
55585
      (void*)&&ZEND_NULL_LABEL,
55586
      (void*)&&ZEND_NULL_LABEL,
55587
      (void*)&&ZEND_NULL_LABEL,
55588
      (void*)&&ZEND_NULL_LABEL,
55589
      (void*)&&ZEND_NULL_LABEL,
55590
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55591
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55592
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55593
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55594
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55595
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55596
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55597
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55598
      (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_NULL_LABEL,
55613
      (void*)&&ZEND_NULL_LABEL,
55614
      (void*)&&ZEND_NULL_LABEL,
55615
      (void*)&&ZEND_NULL_LABEL,
55616
      (void*)&&ZEND_NULL_LABEL,
55617
      (void*)&&ZEND_NULL_LABEL,
55618
      (void*)&&ZEND_NULL_LABEL,
55619
      (void*)&&ZEND_NULL_LABEL,
55620
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_LABEL,
55621
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
55622
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
55623
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
55624
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55625
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55626
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
55627
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55628
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55629
      (void*)&&ZEND_NULL_LABEL,
55630
      (void*)&&ZEND_NULL_LABEL,
55631
      (void*)&&ZEND_NULL_LABEL,
55632
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_LABEL,
55633
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
55634
      (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
55635
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55636
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55637
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55638
      (void*)&&ZEND_NULL_LABEL,
55639
      (void*)&&ZEND_NULL_LABEL,
55640
      (void*)&&ZEND_NULL_LABEL,
55641
      (void*)&&ZEND_NULL_LABEL,
55642
      (void*)&&ZEND_NULL_LABEL,
55643
      (void*)&&ZEND_NULL_LABEL,
55644
      (void*)&&ZEND_NULL_LABEL,
55645
      (void*)&&ZEND_NULL_LABEL,
55646
      (void*)&&ZEND_NULL_LABEL,
55647
      (void*)&&ZEND_NULL_LABEL,
55648
      (void*)&&ZEND_NULL_LABEL,
55649
      (void*)&&ZEND_NULL_LABEL,
55650
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55651
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55652
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55653
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55654
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55655
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55656
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55657
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55658
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55659
      (void*)&&ZEND_NULL_LABEL,
55660
      (void*)&&ZEND_NULL_LABEL,
55661
      (void*)&&ZEND_NULL_LABEL,
55662
      (void*)&&ZEND_NULL_LABEL,
55663
      (void*)&&ZEND_NULL_LABEL,
55664
      (void*)&&ZEND_NULL_LABEL,
55665
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55666
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55667
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55668
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55669
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55670
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55671
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55672
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55673
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_NULL_LABEL,
55688
      (void*)&&ZEND_NULL_LABEL,
55689
      (void*)&&ZEND_NULL_LABEL,
55690
      (void*)&&ZEND_NULL_LABEL,
55691
      (void*)&&ZEND_NULL_LABEL,
55692
      (void*)&&ZEND_NULL_LABEL,
55693
      (void*)&&ZEND_NULL_LABEL,
55694
      (void*)&&ZEND_NULL_LABEL,
55695
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_LABEL,
55696
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
55697
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
55698
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
55699
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55700
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55701
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
55702
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55703
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55704
      (void*)&&ZEND_NULL_LABEL,
55705
      (void*)&&ZEND_NULL_LABEL,
55706
      (void*)&&ZEND_NULL_LABEL,
55707
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_LABEL,
55708
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
55709
      (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
55710
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55711
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55712
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55713
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55714
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55715
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55716
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55717
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55718
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55719
      (void*)&&ZEND_NULL_LABEL,
55720
      (void*)&&ZEND_NULL_LABEL,
55721
      (void*)&&ZEND_NULL_LABEL,
55722
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55723
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55724
      (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55725
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55726
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55727
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55728
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55729
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55730
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55731
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55732
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55733
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55734
      (void*)&&ZEND_NULL_LABEL,
55735
      (void*)&&ZEND_NULL_LABEL,
55736
      (void*)&&ZEND_NULL_LABEL,
55737
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55738
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55739
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55740
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55741
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55742
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55743
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55744
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55745
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55746
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55747
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55748
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55749
      (void*)&&ZEND_NULL_LABEL,
55750
      (void*)&&ZEND_NULL_LABEL,
55751
      (void*)&&ZEND_NULL_LABEL,
55752
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55753
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55754
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
55763
      (void*)&&ZEND_NULL_LABEL,
55764
      (void*)&&ZEND_NULL_LABEL,
55765
      (void*)&&ZEND_NULL_LABEL,
55766
      (void*)&&ZEND_NULL_LABEL,
55767
      (void*)&&ZEND_NULL_LABEL,
55768
      (void*)&&ZEND_NULL_LABEL,
55769
      (void*)&&ZEND_NULL_LABEL,
55770
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55771
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55772
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55773
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55774
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55775
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55776
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55777
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55778
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55779
      (void*)&&ZEND_NULL_LABEL,
55780
      (void*)&&ZEND_NULL_LABEL,
55781
      (void*)&&ZEND_NULL_LABEL,
55782
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55783
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55784
      (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55785
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55786
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55787
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55788
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55789
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55790
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55791
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55792
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55793
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55794
      (void*)&&ZEND_NULL_LABEL,
55795
      (void*)&&ZEND_NULL_LABEL,
55796
      (void*)&&ZEND_NULL_LABEL,
55797
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55798
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55799
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55800
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55801
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55802
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55803
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55804
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55805
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55806
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55807
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55808
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55809
      (void*)&&ZEND_NULL_LABEL,
55810
      (void*)&&ZEND_NULL_LABEL,
55811
      (void*)&&ZEND_NULL_LABEL,
55812
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55813
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55814
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55815
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55816
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55817
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55818
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55819
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55820
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55821
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55822
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55823
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55824
      (void*)&&ZEND_NULL_LABEL,
55825
      (void*)&&ZEND_NULL_LABEL,
55826
      (void*)&&ZEND_NULL_LABEL,
55827
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55828
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55829
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
55838
      (void*)&&ZEND_NULL_LABEL,
55839
      (void*)&&ZEND_NULL_LABEL,
55840
      (void*)&&ZEND_NULL_LABEL,
55841
      (void*)&&ZEND_NULL_LABEL,
55842
      (void*)&&ZEND_NULL_LABEL,
55843
      (void*)&&ZEND_NULL_LABEL,
55844
      (void*)&&ZEND_NULL_LABEL,
55845
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55846
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55847
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55848
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55849
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55850
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55851
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55852
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55853
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55854
      (void*)&&ZEND_NULL_LABEL,
55855
      (void*)&&ZEND_NULL_LABEL,
55856
      (void*)&&ZEND_NULL_LABEL,
55857
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55858
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55859
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
55873
      (void*)&&ZEND_NULL_LABEL,
55874
      (void*)&&ZEND_NULL_LABEL,
55875
      (void*)&&ZEND_NULL_LABEL,
55876
      (void*)&&ZEND_NULL_LABEL,
55877
      (void*)&&ZEND_NULL_LABEL,
55878
      (void*)&&ZEND_NULL_LABEL,
55879
      (void*)&&ZEND_NULL_LABEL,
55880
      (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_LABEL,
55881
      (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_LABEL,
55882
      (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_LABEL,
55883
      (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_LABEL,
55884
      (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_LABEL,
55885
      (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_LABEL,
55886
      (void*)&&ZEND_NULL_LABEL,
55887
      (void*)&&ZEND_NULL_LABEL,
55888
      (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
55889
      (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_LABEL,
55890
      (void*)&&ZEND_NULL_LABEL,
55891
      (void*)&&ZEND_NULL_LABEL,
55892
      (void*)&&ZEND_NULL_LABEL,
55893
      (void*)&&ZEND_NULL_LABEL,
55894
      (void*)&&ZEND_NULL_LABEL,
55895
      (void*)&&ZEND_NULL_LABEL,
55896
      (void*)&&ZEND_NULL_LABEL,
55897
      (void*)&&ZEND_NULL_LABEL,
55898
      (void*)&&ZEND_NULL_LABEL,
55899
      (void*)&&ZEND_NULL_LABEL,
55900
      (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_LABEL,
55901
      (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_LABEL,
55902
      (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_LABEL,
55903
      (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_LABEL,
55904
      (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_LABEL,
55905
      (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_LABEL,
55906
      (void*)&&ZEND_NULL_LABEL,
55907
      (void*)&&ZEND_NULL_LABEL,
55908
      (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_LABEL,
55909
      (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_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_NULL_LABEL,
55953
      (void*)&&ZEND_NULL_LABEL,
55954
      (void*)&&ZEND_NULL_LABEL,
55955
      (void*)&&ZEND_NULL_LABEL,
55956
      (void*)&&ZEND_NULL_LABEL,
55957
      (void*)&&ZEND_NULL_LABEL,
55958
      (void*)&&ZEND_NULL_LABEL,
55959
      (void*)&&ZEND_NULL_LABEL,
55960
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
55961
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
55962
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
55963
      (void*)&&ZEND_NULL_LABEL,
55964
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
55965
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55966
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55967
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55968
      (void*)&&ZEND_NULL_LABEL,
55969
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55970
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55971
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55972
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55973
      (void*)&&ZEND_NULL_LABEL,
55974
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55975
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_LABEL,
55976
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_LABEL,
55977
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_LABEL,
55978
      (void*)&&ZEND_NULL_LABEL,
55979
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_LABEL,
55980
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
55981
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
55982
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
55983
      (void*)&&ZEND_NULL_LABEL,
55984
      (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_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_NULL_LABEL,
56003
      (void*)&&ZEND_NULL_LABEL,
56004
      (void*)&&ZEND_NULL_LABEL,
56005
      (void*)&&ZEND_NULL_LABEL,
56006
      (void*)&&ZEND_NULL_LABEL,
56007
      (void*)&&ZEND_NULL_LABEL,
56008
      (void*)&&ZEND_NULL_LABEL,
56009
      (void*)&&ZEND_NULL_LABEL,
56010
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
56011
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
56012
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56013
      (void*)&&ZEND_NULL_LABEL,
56014
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56015
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56016
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56017
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56018
      (void*)&&ZEND_NULL_LABEL,
56019
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56020
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56021
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56022
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56023
      (void*)&&ZEND_NULL_LABEL,
56024
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56025
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_LABEL,
56026
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_LABEL,
56027
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_LABEL,
56028
      (void*)&&ZEND_NULL_LABEL,
56029
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_LABEL,
56030
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_LABEL,
56031
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_LABEL,
56032
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56033
      (void*)&&ZEND_NULL_LABEL,
56034
      (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_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_NULL_LABEL,
56078
      (void*)&&ZEND_NULL_LABEL,
56079
      (void*)&&ZEND_NULL_LABEL,
56080
      (void*)&&ZEND_NULL_LABEL,
56081
      (void*)&&ZEND_NULL_LABEL,
56082
      (void*)&&ZEND_NULL_LABEL,
56083
      (void*)&&ZEND_NULL_LABEL,
56084
      (void*)&&ZEND_NULL_LABEL,
56085
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
56086
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
56087
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
56088
      (void*)&&ZEND_NULL_LABEL,
56089
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
56090
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
56091
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
56092
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56093
      (void*)&&ZEND_NULL_LABEL,
56094
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56095
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
56096
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
56097
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56098
      (void*)&&ZEND_NULL_LABEL,
56099
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56100
      (void*)&&ZEND_NULL_LABEL,
56101
      (void*)&&ZEND_NULL_LABEL,
56102
      (void*)&&ZEND_NULL_LABEL,
56103
      (void*)&&ZEND_NULL_LABEL,
56104
      (void*)&&ZEND_NULL_LABEL,
56105
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
56106
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
56107
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
56108
      (void*)&&ZEND_NULL_LABEL,
56109
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_LABEL,
56110
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_LABEL,
56111
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_LABEL,
56112
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
56113
      (void*)&&ZEND_NULL_LABEL,
56114
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
56115
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
56116
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
56117
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56118
      (void*)&&ZEND_NULL_LABEL,
56119
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56120
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
56121
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
56122
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56123
      (void*)&&ZEND_NULL_LABEL,
56124
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56125
      (void*)&&ZEND_NULL_LABEL,
56126
      (void*)&&ZEND_NULL_LABEL,
56127
      (void*)&&ZEND_NULL_LABEL,
56128
      (void*)&&ZEND_NULL_LABEL,
56129
      (void*)&&ZEND_NULL_LABEL,
56130
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_LABEL,
56131
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_LABEL,
56132
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
56133
      (void*)&&ZEND_NULL_LABEL,
56134
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
56135
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
56136
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
56137
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56138
      (void*)&&ZEND_NULL_LABEL,
56139
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56140
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56141
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56142
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56143
      (void*)&&ZEND_NULL_LABEL,
56144
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56145
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56146
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56147
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56148
      (void*)&&ZEND_NULL_LABEL,
56149
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56150
      (void*)&&ZEND_NULL_LABEL,
56151
      (void*)&&ZEND_NULL_LABEL,
56152
      (void*)&&ZEND_NULL_LABEL,
56153
      (void*)&&ZEND_NULL_LABEL,
56154
      (void*)&&ZEND_NULL_LABEL,
56155
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_LABEL,
56156
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_LABEL,
56157
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56158
      (void*)&&ZEND_NULL_LABEL,
56159
      (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_LABEL,
56160
      (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_LABEL,
56161
      (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_LABEL,
56162
      (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_LABEL,
56163
      (void*)&&ZEND_NULL_LABEL,
56164
      (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_LABEL,
56165
      (void*)&&ZEND_NULL_LABEL,
56166
      (void*)&&ZEND_NULL_LABEL,
56167
      (void*)&&ZEND_NULL_LABEL,
56168
      (void*)&&ZEND_NULL_LABEL,
56169
      (void*)&&ZEND_NULL_LABEL,
56170
      (void*)&&ZEND_NULL_LABEL,
56171
      (void*)&&ZEND_NULL_LABEL,
56172
      (void*)&&ZEND_NULL_LABEL,
56173
      (void*)&&ZEND_NULL_LABEL,
56174
      (void*)&&ZEND_NULL_LABEL,
56175
      (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CONST_LABEL,
56176
      (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
56177
      (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
56178
      (void*)&&ZEND_NULL_LABEL,
56179
      (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CV_LABEL,
56180
      (void*)&&ZEND_NULL_LABEL,
56181
      (void*)&&ZEND_NULL_LABEL,
56182
      (void*)&&ZEND_NULL_LABEL,
56183
      (void*)&&ZEND_NULL_LABEL,
56184
      (void*)&&ZEND_NULL_LABEL,
56185
      (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CONST_LABEL,
56186
      (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
56187
      (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
56188
      (void*)&&ZEND_NULL_LABEL,
56189
      (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CV_LABEL,
56190
      (void*)&&ZEND_NULL_LABEL,
56191
      (void*)&&ZEND_NULL_LABEL,
56192
      (void*)&&ZEND_NULL_LABEL,
56193
      (void*)&&ZEND_NULL_LABEL,
56194
      (void*)&&ZEND_NULL_LABEL,
56195
      (void*)&&ZEND_NULL_LABEL,
56196
      (void*)&&ZEND_NULL_LABEL,
56197
      (void*)&&ZEND_NULL_LABEL,
56198
      (void*)&&ZEND_NULL_LABEL,
56199
      (void*)&&ZEND_NULL_LABEL,
56200
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_LABEL,
56201
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
56202
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
56203
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_LABEL,
56204
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_LABEL,
56205
      (void*)&&ZEND_NULL_LABEL,
56206
      (void*)&&ZEND_NULL_LABEL,
56207
      (void*)&&ZEND_NULL_LABEL,
56208
      (void*)&&ZEND_NULL_LABEL,
56209
      (void*)&&ZEND_NULL_LABEL,
56210
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_LABEL,
56211
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
56212
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
56213
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_LABEL,
56214
      (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_LABEL,
56215
      (void*)&&ZEND_NULL_LABEL,
56216
      (void*)&&ZEND_NULL_LABEL,
56217
      (void*)&&ZEND_NULL_LABEL,
56218
      (void*)&&ZEND_NULL_LABEL,
56219
      (void*)&&ZEND_NULL_LABEL,
56220
      (void*)&&ZEND_NULL_LABEL,
56221
      (void*)&&ZEND_NULL_LABEL,
56222
      (void*)&&ZEND_NULL_LABEL,
56223
      (void*)&&ZEND_NULL_LABEL,
56224
      (void*)&&ZEND_NULL_LABEL,
56225
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_LABEL,
56226
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
56227
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
56228
      (void*)&&ZEND_NULL_LABEL,
56229
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_LABEL,
56230
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_LABEL,
56231
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
56232
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
56233
      (void*)&&ZEND_NULL_LABEL,
56234
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_LABEL,
56235
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_LABEL,
56236
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
56237
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
56238
      (void*)&&ZEND_NULL_LABEL,
56239
      (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_LABEL,
56240
      (void*)&&ZEND_ASSIGN_STATIC_PROP_OP_SPEC_LABEL,
56241
      (void*)&&ZEND_NULL_LABEL,
56242
      (void*)&&ZEND_NULL_LABEL,
56243
      (void*)&&ZEND_NULL_LABEL,
56244
      (void*)&&ZEND_NULL_LABEL,
56245
      (void*)&&ZEND_NULL_LABEL,
56246
      (void*)&&ZEND_NULL_LABEL,
56247
      (void*)&&ZEND_NULL_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_ASSIGN_REF_SPEC_VAR_VAR_LABEL,
56254
      (void*)&&ZEND_NULL_LABEL,
56255
      (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_CV_LABEL,
56256
      (void*)&&ZEND_NULL_LABEL,
56257
      (void*)&&ZEND_NULL_LABEL,
56258
      (void*)&&ZEND_NULL_LABEL,
56259
      (void*)&&ZEND_NULL_LABEL,
56260
      (void*)&&ZEND_NULL_LABEL,
56261
      (void*)&&ZEND_NULL_LABEL,
56262
      (void*)&&ZEND_NULL_LABEL,
56263
      (void*)&&ZEND_ASSIGN_REF_SPEC_CV_VAR_LABEL,
56264
      (void*)&&ZEND_NULL_LABEL,
56265
      (void*)&&ZEND_ASSIGN_REF_SPEC_CV_CV_LABEL,
56266
      (void*)&&ZEND_QM_ASSIGN_SPEC_CONST_LABEL,
56267
      (void*)&&ZEND_QM_ASSIGN_SPEC_TMP_LABEL,
56268
      (void*)&&ZEND_QM_ASSIGN_SPEC_VAR_LABEL,
56269
      (void*)&&ZEND_NULL_LABEL,
56270
      (void*)&&ZEND_QM_ASSIGN_SPEC_CV_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_NULL_LABEL,
56316
      (void*)&&ZEND_NULL_LABEL,
56317
      (void*)&&ZEND_NULL_LABEL,
56318
      (void*)&&ZEND_NULL_LABEL,
56319
      (void*)&&ZEND_NULL_LABEL,
56320
      (void*)&&ZEND_NULL_LABEL,
56321
      (void*)&&ZEND_NULL_LABEL,
56322
      (void*)&&ZEND_NULL_LABEL,
56323
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
56324
      (void*)&&ZEND_NULL_LABEL,
56325
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
56326
      (void*)&&ZEND_NULL_LABEL,
56327
      (void*)&&ZEND_NULL_LABEL,
56328
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56329
      (void*)&&ZEND_NULL_LABEL,
56330
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56331
      (void*)&&ZEND_NULL_LABEL,
56332
      (void*)&&ZEND_NULL_LABEL,
56333
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56334
      (void*)&&ZEND_NULL_LABEL,
56335
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56336
      (void*)&&ZEND_NULL_LABEL,
56337
      (void*)&&ZEND_NULL_LABEL,
56338
      (void*)&&ZEND_NULL_LABEL,
56339
      (void*)&&ZEND_NULL_LABEL,
56340
      (void*)&&ZEND_NULL_LABEL,
56341
      (void*)&&ZEND_NULL_LABEL,
56342
      (void*)&&ZEND_NULL_LABEL,
56343
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
56344
      (void*)&&ZEND_NULL_LABEL,
56345
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_LABEL,
56346
      (void*)&&ZEND_NULL_LABEL,
56347
      (void*)&&ZEND_NULL_LABEL,
56348
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
56349
      (void*)&&ZEND_NULL_LABEL,
56350
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
56351
      (void*)&&ZEND_NULL_LABEL,
56352
      (void*)&&ZEND_NULL_LABEL,
56353
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56354
      (void*)&&ZEND_NULL_LABEL,
56355
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56356
      (void*)&&ZEND_NULL_LABEL,
56357
      (void*)&&ZEND_NULL_LABEL,
56358
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56359
      (void*)&&ZEND_NULL_LABEL,
56360
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56361
      (void*)&&ZEND_NULL_LABEL,
56362
      (void*)&&ZEND_NULL_LABEL,
56363
      (void*)&&ZEND_NULL_LABEL,
56364
      (void*)&&ZEND_NULL_LABEL,
56365
      (void*)&&ZEND_NULL_LABEL,
56366
      (void*)&&ZEND_NULL_LABEL,
56367
      (void*)&&ZEND_NULL_LABEL,
56368
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
56369
      (void*)&&ZEND_NULL_LABEL,
56370
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
56371
      (void*)&&ZEND_NULL_LABEL,
56372
      (void*)&&ZEND_NULL_LABEL,
56373
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56374
      (void*)&&ZEND_NULL_LABEL,
56375
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56376
      (void*)&&ZEND_NULL_LABEL,
56377
      (void*)&&ZEND_NULL_LABEL,
56378
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56379
      (void*)&&ZEND_NULL_LABEL,
56380
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56381
      (void*)&&ZEND_NULL_LABEL,
56382
      (void*)&&ZEND_NULL_LABEL,
56383
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56384
      (void*)&&ZEND_NULL_LABEL,
56385
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56386
      (void*)&&ZEND_NULL_LABEL,
56387
      (void*)&&ZEND_NULL_LABEL,
56388
      (void*)&&ZEND_NULL_LABEL,
56389
      (void*)&&ZEND_NULL_LABEL,
56390
      (void*)&&ZEND_NULL_LABEL,
56391
      (void*)&&ZEND_NULL_LABEL,
56392
      (void*)&&ZEND_NULL_LABEL,
56393
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56394
      (void*)&&ZEND_NULL_LABEL,
56395
      (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_LABEL,
56396
      (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_LABEL,
56397
      (void*)&&ZEND_NULL_LABEL,
56398
      (void*)&&ZEND_NULL_LABEL,
56399
      (void*)&&ZEND_NULL_LABEL,
56400
      (void*)&&ZEND_NULL_LABEL,
56401
      (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_LABEL,
56402
      (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_LABEL,
56403
      (void*)&&ZEND_NULL_LABEL,
56404
      (void*)&&ZEND_NULL_LABEL,
56405
      (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_LABEL,
56406
      (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_USED_LABEL,
56407
      (void*)&&ZEND_NULL_LABEL,
56408
      (void*)&&ZEND_NULL_LABEL,
56409
      (void*)&&ZEND_NULL_LABEL,
56410
      (void*)&&ZEND_NULL_LABEL,
56411
      (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_LABEL,
56412
      (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_LABEL,
56413
      (void*)&&ZEND_NULL_LABEL,
56414
      (void*)&&ZEND_NULL_LABEL,
56415
      (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_LABEL,
56416
      (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_LABEL,
56417
      (void*)&&ZEND_NULL_LABEL,
56418
      (void*)&&ZEND_NULL_LABEL,
56419
      (void*)&&ZEND_POST_INC_SPEC_VAR_LABEL,
56420
      (void*)&&ZEND_NULL_LABEL,
56421
      (void*)&&ZEND_POST_INC_SPEC_CV_LABEL,
56422
      (void*)&&ZEND_NULL_LABEL,
56423
      (void*)&&ZEND_NULL_LABEL,
56424
      (void*)&&ZEND_POST_DEC_SPEC_VAR_LABEL,
56425
      (void*)&&ZEND_NULL_LABEL,
56426
      (void*)&&ZEND_POST_DEC_SPEC_CV_LABEL,
56427
      (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_LABEL,
56428
      (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_LABEL,
56429
      (void*)&&ZEND_JMP_SPEC_LABEL,
56430
      (void*)&&ZEND_JMPZ_SPEC_CONST_LABEL,
56431
      (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
56432
      (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
56433
      (void*)&&ZEND_NULL_LABEL,
56434
      (void*)&&ZEND_JMPZ_SPEC_CV_LABEL,
56435
      (void*)&&ZEND_JMPNZ_SPEC_CONST_LABEL,
56436
      (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
56437
      (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
56438
      (void*)&&ZEND_NULL_LABEL,
56439
      (void*)&&ZEND_JMPNZ_SPEC_CV_LABEL,
56440
      (void*)&&ZEND_JMPZ_EX_SPEC_CONST_LABEL,
56441
      (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
56442
      (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
56443
      (void*)&&ZEND_NULL_LABEL,
56444
      (void*)&&ZEND_JMPZ_EX_SPEC_CV_LABEL,
56445
      (void*)&&ZEND_JMPNZ_EX_SPEC_CONST_LABEL,
56446
      (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
56447
      (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
56448
      (void*)&&ZEND_NULL_LABEL,
56449
      (void*)&&ZEND_JMPNZ_EX_SPEC_CV_LABEL,
56450
      (void*)&&ZEND_CASE_SPEC_TMPVAR_CONST_LABEL,
56451
      (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
56452
      (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
56453
      (void*)&&ZEND_NULL_LABEL,
56454
      (void*)&&ZEND_CASE_SPEC_TMPVAR_CV_LABEL,
56455
      (void*)&&ZEND_CHECK_VAR_SPEC_CV_UNUSED_LABEL,
56456
      (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
56457
      (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
56458
      (void*)&&ZEND_NULL_LABEL,
56459
      (void*)&&ZEND_NULL_LABEL,
56460
      (void*)&&ZEND_NULL_LABEL,
56461
      (void*)&&ZEND_NULL_LABEL,
56462
      (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_LABEL,
56463
      (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
56464
      (void*)&&ZEND_NULL_LABEL,
56465
      (void*)&&ZEND_NULL_LABEL,
56466
      (void*)&&ZEND_CAST_SPEC_CONST_LABEL,
56467
      (void*)&&ZEND_CAST_SPEC_TMP_LABEL,
56468
      (void*)&&ZEND_CAST_SPEC_VAR_LABEL,
56469
      (void*)&&ZEND_NULL_LABEL,
56470
      (void*)&&ZEND_CAST_SPEC_CV_LABEL,
56471
      (void*)&&ZEND_BOOL_SPEC_CONST_LABEL,
56472
      (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
56473
      (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
56474
      (void*)&&ZEND_NULL_LABEL,
56475
      (void*)&&ZEND_BOOL_SPEC_CV_LABEL,
56476
      (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CONST_LABEL,
56477
      (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
56478
      (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
56479
      (void*)&&ZEND_NULL_LABEL,
56480
      (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CV_LABEL,
56481
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
56482
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56483
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56484
      (void*)&&ZEND_NULL_LABEL,
56485
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
56486
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
56487
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56488
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56489
      (void*)&&ZEND_NULL_LABEL,
56490
      (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
56491
      (void*)&&ZEND_NULL_LABEL,
56492
      (void*)&&ZEND_NULL_LABEL,
56493
      (void*)&&ZEND_NULL_LABEL,
56494
      (void*)&&ZEND_NULL_LABEL,
56495
      (void*)&&ZEND_NULL_LABEL,
56496
      (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CONST_LABEL,
56497
      (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
56498
      (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
56499
      (void*)&&ZEND_NULL_LABEL,
56500
      (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CV_LABEL,
56501
      (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CONST_LABEL,
56502
      (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
56503
      (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
56504
      (void*)&&ZEND_NULL_LABEL,
56505
      (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CV_LABEL,
56506
      (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CONST_LABEL,
56507
      (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
56508
      (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
56509
      (void*)&&ZEND_NULL_LABEL,
56510
      (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CV_LABEL,
56511
      (void*)&&ZEND_ROPE_END_SPEC_TMP_CONST_LABEL,
56512
      (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
56513
      (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
56514
      (void*)&&ZEND_NULL_LABEL,
56515
      (void*)&&ZEND_ROPE_END_SPEC_TMP_CV_LABEL,
56516
      (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL,
56517
      (void*)&&ZEND_END_SILENCE_SPEC_TMP_LABEL,
56518
      (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL,
56519
      (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL,
56520
      (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL,
56521
      (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
56522
      (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
56523
      (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL,
56524
      (void*)&&ZEND_RETURN_SPEC_CONST_LABEL,
56525
      (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56526
      (void*)&&ZEND_RETURN_SPEC_TMP_LABEL,
56527
      (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56528
      (void*)&&ZEND_RETURN_SPEC_VAR_LABEL,
56529
      (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56530
      (void*)&&ZEND_NULL_LABEL,
56531
      (void*)&&ZEND_NULL_LABEL,
56532
      (void*)&&ZEND_RETURN_SPEC_CV_LABEL,
56533
      (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56534
      (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL,
56535
      (void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL,
56536
      (void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL,
56537
      (void*)&&ZEND_NULL_LABEL,
56538
      (void*)&&ZEND_NULL_LABEL,
56539
      (void*)&&ZEND_SEND_VAL_SPEC_CONST_UNUSED_LABEL,
56540
      (void*)&&ZEND_NULL_LABEL,
56541
      (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
56542
      (void*)&&ZEND_NULL_LABEL,
56543
      (void*)&&ZEND_NULL_LABEL,
56544
      (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
56545
      (void*)&&ZEND_NULL_LABEL,
56546
      (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
56547
      (void*)&&ZEND_NULL_LABEL,
56548
      (void*)&&ZEND_NULL_LABEL,
56549
      (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_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_NULL_LABEL,
56574
      (void*)&&ZEND_NULL_LABEL,
56575
      (void*)&&ZEND_NULL_LABEL,
56576
      (void*)&&ZEND_NULL_LABEL,
56577
      (void*)&&ZEND_NULL_LABEL,
56578
      (void*)&&ZEND_NULL_LABEL,
56579
      (void*)&&ZEND_NULL_LABEL,
56580
      (void*)&&ZEND_NULL_LABEL,
56581
      (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
56582
      (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
56583
      (void*)&&ZEND_NULL_LABEL,
56584
      (void*)&&ZEND_NULL_LABEL,
56585
      (void*)&&ZEND_NULL_LABEL,
56586
      (void*)&&ZEND_NULL_LABEL,
56587
      (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_LABEL,
56588
      (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
56589
      (void*)&&ZEND_NULL_LABEL,
56590
      (void*)&&ZEND_NULL_LABEL,
56591
      (void*)&&ZEND_NULL_LABEL,
56592
      (void*)&&ZEND_NULL_LABEL,
56593
      (void*)&&ZEND_NULL_LABEL,
56594
      (void*)&&ZEND_NULL_LABEL,
56595
      (void*)&&ZEND_NULL_LABEL,
56596
      (void*)&&ZEND_NULL_LABEL,
56597
      (void*)&&ZEND_NULL_LABEL,
56598
      (void*)&&ZEND_NULL_LABEL,
56599
      (void*)&&ZEND_NULL_LABEL,
56600
      (void*)&&ZEND_NULL_LABEL,
56601
      (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
56602
      (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
56603
      (void*)&&ZEND_NULL_LABEL,
56604
      (void*)&&ZEND_NULL_LABEL,
56605
      (void*)&&ZEND_NULL_LABEL,
56606
      (void*)&&ZEND_NULL_LABEL,
56607
      (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_LABEL,
56608
      (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_LABEL,
56609
      (void*)&&ZEND_NULL_LABEL,
56610
      (void*)&&ZEND_NULL_LABEL,
56611
      (void*)&&ZEND_NULL_LABEL,
56612
      (void*)&&ZEND_NULL_LABEL,
56613
      (void*)&&ZEND_NULL_LABEL,
56614
      (void*)&&ZEND_NULL_LABEL,
56615
      (void*)&&ZEND_NULL_LABEL,
56616
      (void*)&&ZEND_NULL_LABEL,
56617
      (void*)&&ZEND_NULL_LABEL,
56618
      (void*)&&ZEND_NULL_LABEL,
56619
      (void*)&&ZEND_NULL_LABEL,
56620
      (void*)&&ZEND_NULL_LABEL,
56621
      (void*)&&ZEND_SEND_REF_SPEC_VAR_CONST_LABEL,
56622
      (void*)&&ZEND_NULL_LABEL,
56623
      (void*)&&ZEND_NULL_LABEL,
56624
      (void*)&&ZEND_SEND_REF_SPEC_VAR_UNUSED_LABEL,
56625
      (void*)&&ZEND_NULL_LABEL,
56626
      (void*)&&ZEND_NULL_LABEL,
56627
      (void*)&&ZEND_NULL_LABEL,
56628
      (void*)&&ZEND_NULL_LABEL,
56629
      (void*)&&ZEND_NULL_LABEL,
56630
      (void*)&&ZEND_NULL_LABEL,
56631
      (void*)&&ZEND_SEND_REF_SPEC_CV_CONST_LABEL,
56632
      (void*)&&ZEND_NULL_LABEL,
56633
      (void*)&&ZEND_NULL_LABEL,
56634
      (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL,
56635
      (void*)&&ZEND_NULL_LABEL,
56636
      (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL,
56637
      (void*)&&ZEND_NULL_LABEL,
56638
      (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL,
56639
      (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL,
56640
      (void*)&&ZEND_NULL_LABEL,
56641
      (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL,
56642
      (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL,
56643
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL,
56644
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
56645
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
56646
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_LABEL,
56647
      (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CV_LABEL,
56648
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CONST_LABEL,
56649
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
56650
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
56651
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_LABEL,
56652
      (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CV_LABEL,
56653
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CONST_LABEL,
56654
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
56655
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
56656
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_LABEL,
56657
      (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CV_LABEL,
56658
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_LABEL,
56659
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
56660
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
56661
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_LABEL,
56662
      (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CV_LABEL,
56663
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CONST_LABEL,
56664
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
56665
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
56666
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_UNUSED_LABEL,
56667
      (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CV_LABEL,
56668
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_LABEL,
56669
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
56670
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
56671
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_LABEL,
56672
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_LABEL,
56673
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_LABEL,
56674
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
56675
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
56676
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_LABEL,
56677
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_LABEL,
56678
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_LABEL,
56679
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
56680
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
56681
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_LABEL,
56682
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_LABEL,
56683
      (void*)&&ZEND_NULL_LABEL,
56684
      (void*)&&ZEND_NULL_LABEL,
56685
      (void*)&&ZEND_NULL_LABEL,
56686
      (void*)&&ZEND_NULL_LABEL,
56687
      (void*)&&ZEND_NULL_LABEL,
56688
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_LABEL,
56689
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
56690
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
56691
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL,
56692
      (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL,
56693
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL,
56694
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56695
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
56696
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56697
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
56698
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56699
      (void*)&&ZEND_NULL_LABEL,
56700
      (void*)&&ZEND_NULL_LABEL,
56701
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL,
56702
      (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56703
      (void*)&&ZEND_UNSET_VAR_SPEC_CONST_UNUSED_LABEL,
56704
      (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
56705
      (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
56706
      (void*)&&ZEND_NULL_LABEL,
56707
      (void*)&&ZEND_UNSET_VAR_SPEC_CV_UNUSED_LABEL,
56708
      (void*)&&ZEND_NULL_LABEL,
56709
      (void*)&&ZEND_NULL_LABEL,
56710
      (void*)&&ZEND_NULL_LABEL,
56711
      (void*)&&ZEND_NULL_LABEL,
56712
      (void*)&&ZEND_NULL_LABEL,
56713
      (void*)&&ZEND_NULL_LABEL,
56714
      (void*)&&ZEND_NULL_LABEL,
56715
      (void*)&&ZEND_NULL_LABEL,
56716
      (void*)&&ZEND_NULL_LABEL,
56717
      (void*)&&ZEND_NULL_LABEL,
56718
      (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CONST_LABEL,
56719
      (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
56720
      (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
56721
      (void*)&&ZEND_NULL_LABEL,
56722
      (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CV_LABEL,
56723
      (void*)&&ZEND_NULL_LABEL,
56724
      (void*)&&ZEND_NULL_LABEL,
56725
      (void*)&&ZEND_NULL_LABEL,
56726
      (void*)&&ZEND_NULL_LABEL,
56727
      (void*)&&ZEND_NULL_LABEL,
56728
      (void*)&&ZEND_UNSET_DIM_SPEC_CV_CONST_LABEL,
56729
      (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
56730
      (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
56731
      (void*)&&ZEND_NULL_LABEL,
56732
      (void*)&&ZEND_UNSET_DIM_SPEC_CV_CV_LABEL,
56733
      (void*)&&ZEND_NULL_LABEL,
56734
      (void*)&&ZEND_NULL_LABEL,
56735
      (void*)&&ZEND_NULL_LABEL,
56736
      (void*)&&ZEND_NULL_LABEL,
56737
      (void*)&&ZEND_NULL_LABEL,
56738
      (void*)&&ZEND_NULL_LABEL,
56739
      (void*)&&ZEND_NULL_LABEL,
56740
      (void*)&&ZEND_NULL_LABEL,
56741
      (void*)&&ZEND_NULL_LABEL,
56742
      (void*)&&ZEND_NULL_LABEL,
56743
      (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CONST_LABEL,
56744
      (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
56745
      (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
56746
      (void*)&&ZEND_NULL_LABEL,
56747
      (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CV_LABEL,
56748
      (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_LABEL,
56749
      (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
56750
      (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
56751
      (void*)&&ZEND_NULL_LABEL,
56752
      (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CV_LABEL,
56753
      (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CONST_LABEL,
56754
      (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
56755
      (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
56756
      (void*)&&ZEND_NULL_LABEL,
56757
      (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CV_LABEL,
56758
      (void*)&&ZEND_FE_RESET_R_SPEC_CONST_LABEL,
56759
      (void*)&&ZEND_FE_RESET_R_SPEC_TMP_LABEL,
56760
      (void*)&&ZEND_FE_RESET_R_SPEC_VAR_LABEL,
56761
      (void*)&&ZEND_NULL_LABEL,
56762
      (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL,
56763
      (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL,
56764
      (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL,
56765
      (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
56766
      (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
56767
      (void*)&&ZEND_NULL_LABEL,
56768
      (void*)&&ZEND_FETCH_R_SPEC_CV_UNUSED_LABEL,
56769
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CONST_LABEL,
56770
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
56771
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
56772
      (void*)&&ZEND_NULL_LABEL,
56773
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CV_LABEL,
56774
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
56775
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56776
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56777
      (void*)&&ZEND_NULL_LABEL,
56778
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
56779
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
56780
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56781
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56782
      (void*)&&ZEND_NULL_LABEL,
56783
      (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
56784
      (void*)&&ZEND_NULL_LABEL,
56785
      (void*)&&ZEND_NULL_LABEL,
56786
      (void*)&&ZEND_NULL_LABEL,
56787
      (void*)&&ZEND_NULL_LABEL,
56788
      (void*)&&ZEND_NULL_LABEL,
56789
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CONST_LABEL,
56790
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
56791
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
56792
      (void*)&&ZEND_NULL_LABEL,
56793
      (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CV_LABEL,
56794
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_LABEL,
56795
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
56796
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
56797
      (void*)&&ZEND_NULL_LABEL,
56798
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CV_LABEL,
56799
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
56800
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56801
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56802
      (void*)&&ZEND_NULL_LABEL,
56803
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
56804
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
56805
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56806
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56807
      (void*)&&ZEND_NULL_LABEL,
56808
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
56809
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_LABEL,
56810
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
56811
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
56812
      (void*)&&ZEND_NULL_LABEL,
56813
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_LABEL,
56814
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CONST_LABEL,
56815
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
56816
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
56817
      (void*)&&ZEND_NULL_LABEL,
56818
      (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CV_LABEL,
56819
      (void*)&&ZEND_FETCH_W_SPEC_CONST_UNUSED_LABEL,
56820
      (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
56821
      (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
56822
      (void*)&&ZEND_NULL_LABEL,
56823
      (void*)&&ZEND_FETCH_W_SPEC_CV_UNUSED_LABEL,
56824
      (void*)&&ZEND_NULL_LABEL,
56825
      (void*)&&ZEND_NULL_LABEL,
56826
      (void*)&&ZEND_NULL_LABEL,
56827
      (void*)&&ZEND_NULL_LABEL,
56828
      (void*)&&ZEND_NULL_LABEL,
56829
      (void*)&&ZEND_NULL_LABEL,
56830
      (void*)&&ZEND_NULL_LABEL,
56831
      (void*)&&ZEND_NULL_LABEL,
56832
      (void*)&&ZEND_NULL_LABEL,
56833
      (void*)&&ZEND_NULL_LABEL,
56834
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CONST_LABEL,
56835
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
56836
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
56837
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_LABEL,
56838
      (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CV_LABEL,
56839
      (void*)&&ZEND_NULL_LABEL,
56840
      (void*)&&ZEND_NULL_LABEL,
56841
      (void*)&&ZEND_NULL_LABEL,
56842
      (void*)&&ZEND_NULL_LABEL,
56843
      (void*)&&ZEND_NULL_LABEL,
56844
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CONST_LABEL,
56845
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
56846
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
56847
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_LABEL,
56848
      (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CV_LABEL,
56849
      (void*)&&ZEND_NULL_LABEL,
56850
      (void*)&&ZEND_NULL_LABEL,
56851
      (void*)&&ZEND_NULL_LABEL,
56852
      (void*)&&ZEND_NULL_LABEL,
56853
      (void*)&&ZEND_NULL_LABEL,
56854
      (void*)&&ZEND_NULL_LABEL,
56855
      (void*)&&ZEND_NULL_LABEL,
56856
      (void*)&&ZEND_NULL_LABEL,
56857
      (void*)&&ZEND_NULL_LABEL,
56858
      (void*)&&ZEND_NULL_LABEL,
56859
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_LABEL,
56860
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
56861
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
56862
      (void*)&&ZEND_NULL_LABEL,
56863
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CV_LABEL,
56864
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_LABEL,
56865
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
56866
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
56867
      (void*)&&ZEND_NULL_LABEL,
56868
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_LABEL,
56869
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CONST_LABEL,
56870
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
56871
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
56872
      (void*)&&ZEND_NULL_LABEL,
56873
      (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CV_LABEL,
56874
      (void*)&&ZEND_FETCH_RW_SPEC_CONST_UNUSED_LABEL,
56875
      (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
56876
      (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
56877
      (void*)&&ZEND_NULL_LABEL,
56878
      (void*)&&ZEND_FETCH_RW_SPEC_CV_UNUSED_LABEL,
56879
      (void*)&&ZEND_NULL_LABEL,
56880
      (void*)&&ZEND_NULL_LABEL,
56881
      (void*)&&ZEND_NULL_LABEL,
56882
      (void*)&&ZEND_NULL_LABEL,
56883
      (void*)&&ZEND_NULL_LABEL,
56884
      (void*)&&ZEND_NULL_LABEL,
56885
      (void*)&&ZEND_NULL_LABEL,
56886
      (void*)&&ZEND_NULL_LABEL,
56887
      (void*)&&ZEND_NULL_LABEL,
56888
      (void*)&&ZEND_NULL_LABEL,
56889
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_LABEL,
56890
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
56891
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
56892
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_LABEL,
56893
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CV_LABEL,
56894
      (void*)&&ZEND_NULL_LABEL,
56895
      (void*)&&ZEND_NULL_LABEL,
56896
      (void*)&&ZEND_NULL_LABEL,
56897
      (void*)&&ZEND_NULL_LABEL,
56898
      (void*)&&ZEND_NULL_LABEL,
56899
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CONST_LABEL,
56900
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
56901
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
56902
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_LABEL,
56903
      (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CV_LABEL,
56904
      (void*)&&ZEND_NULL_LABEL,
56905
      (void*)&&ZEND_NULL_LABEL,
56906
      (void*)&&ZEND_NULL_LABEL,
56907
      (void*)&&ZEND_NULL_LABEL,
56908
      (void*)&&ZEND_NULL_LABEL,
56909
      (void*)&&ZEND_NULL_LABEL,
56910
      (void*)&&ZEND_NULL_LABEL,
56911
      (void*)&&ZEND_NULL_LABEL,
56912
      (void*)&&ZEND_NULL_LABEL,
56913
      (void*)&&ZEND_NULL_LABEL,
56914
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_LABEL,
56915
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
56916
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
56917
      (void*)&&ZEND_NULL_LABEL,
56918
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_LABEL,
56919
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_LABEL,
56920
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
56921
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
56922
      (void*)&&ZEND_NULL_LABEL,
56923
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_LABEL,
56924
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_LABEL,
56925
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
56926
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
56927
      (void*)&&ZEND_NULL_LABEL,
56928
      (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CV_LABEL,
56929
      (void*)&&ZEND_FETCH_IS_SPEC_CONST_UNUSED_LABEL,
56930
      (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
56931
      (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
56932
      (void*)&&ZEND_NULL_LABEL,
56933
      (void*)&&ZEND_FETCH_IS_SPEC_CV_UNUSED_LABEL,
56934
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_LABEL,
56935
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
56936
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
56937
      (void*)&&ZEND_NULL_LABEL,
56938
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CV_LABEL,
56939
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
56940
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56941
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56942
      (void*)&&ZEND_NULL_LABEL,
56943
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
56944
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
56945
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56946
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56947
      (void*)&&ZEND_NULL_LABEL,
56948
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
56949
      (void*)&&ZEND_NULL_LABEL,
56950
      (void*)&&ZEND_NULL_LABEL,
56951
      (void*)&&ZEND_NULL_LABEL,
56952
      (void*)&&ZEND_NULL_LABEL,
56953
      (void*)&&ZEND_NULL_LABEL,
56954
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CONST_LABEL,
56955
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
56956
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
56957
      (void*)&&ZEND_NULL_LABEL,
56958
      (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CV_LABEL,
56959
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_LABEL,
56960
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
56961
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
56962
      (void*)&&ZEND_NULL_LABEL,
56963
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_LABEL,
56964
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
56965
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56966
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56967
      (void*)&&ZEND_NULL_LABEL,
56968
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
56969
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
56970
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56971
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56972
      (void*)&&ZEND_NULL_LABEL,
56973
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
56974
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_LABEL,
56975
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
56976
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
56977
      (void*)&&ZEND_NULL_LABEL,
56978
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_LABEL,
56979
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_LABEL,
56980
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
56981
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
56982
      (void*)&&ZEND_NULL_LABEL,
56983
      (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CV_LABEL,
56984
      (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
56985
      (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
56986
      (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
56987
      (void*)&&ZEND_NULL_LABEL,
56988
      (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
56989
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_LABEL,
56990
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56991
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56992
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
56993
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_LABEL,
56994
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_LABEL,
56995
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56996
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56997
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_LABEL,
56998
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_LABEL,
56999
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_LABEL,
57000
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
57001
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
57002
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
57003
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_LABEL,
57004
      (void*)&&ZEND_NULL_LABEL,
57005
      (void*)&&ZEND_NULL_LABEL,
57006
      (void*)&&ZEND_NULL_LABEL,
57007
      (void*)&&ZEND_NULL_LABEL,
57008
      (void*)&&ZEND_NULL_LABEL,
57009
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_LABEL,
57010
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
57011
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
57012
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
57013
      (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_LABEL,
57014
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_LABEL,
57015
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
57016
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
57017
      (void*)&&ZEND_NULL_LABEL,
57018
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_LABEL,
57019
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_LABEL,
57020
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
57021
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
57022
      (void*)&&ZEND_NULL_LABEL,
57023
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_LABEL,
57024
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_LABEL,
57025
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
57026
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
57027
      (void*)&&ZEND_NULL_LABEL,
57028
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_LABEL,
57029
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
57030
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
57031
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
57032
      (void*)&&ZEND_NULL_LABEL,
57033
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_LABEL,
57034
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_LABEL,
57035
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
57036
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
57037
      (void*)&&ZEND_NULL_LABEL,
57038
      (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_LABEL,
57039
      (void*)&&ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_LABEL,
57040
      (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
57041
      (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
57042
      (void*)&&ZEND_NULL_LABEL,
57043
      (void*)&&ZEND_FETCH_UNSET_SPEC_CV_UNUSED_LABEL,
57044
      (void*)&&ZEND_NULL_LABEL,
57045
      (void*)&&ZEND_NULL_LABEL,
57046
      (void*)&&ZEND_NULL_LABEL,
57047
      (void*)&&ZEND_NULL_LABEL,
57048
      (void*)&&ZEND_NULL_LABEL,
57049
      (void*)&&ZEND_NULL_LABEL,
57050
      (void*)&&ZEND_NULL_LABEL,
57051
      (void*)&&ZEND_NULL_LABEL,
57052
      (void*)&&ZEND_NULL_LABEL,
57053
      (void*)&&ZEND_NULL_LABEL,
57054
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_LABEL,
57055
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
57056
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
57057
      (void*)&&ZEND_NULL_LABEL,
57058
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_LABEL,
57059
      (void*)&&ZEND_NULL_LABEL,
57060
      (void*)&&ZEND_NULL_LABEL,
57061
      (void*)&&ZEND_NULL_LABEL,
57062
      (void*)&&ZEND_NULL_LABEL,
57063
      (void*)&&ZEND_NULL_LABEL,
57064
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_LABEL,
57065
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
57066
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
57067
      (void*)&&ZEND_NULL_LABEL,
57068
      (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_LABEL,
57069
      (void*)&&ZEND_NULL_LABEL,
57070
      (void*)&&ZEND_NULL_LABEL,
57071
      (void*)&&ZEND_NULL_LABEL,
57072
      (void*)&&ZEND_NULL_LABEL,
57073
      (void*)&&ZEND_NULL_LABEL,
57074
      (void*)&&ZEND_NULL_LABEL,
57075
      (void*)&&ZEND_NULL_LABEL,
57076
      (void*)&&ZEND_NULL_LABEL,
57077
      (void*)&&ZEND_NULL_LABEL,
57078
      (void*)&&ZEND_NULL_LABEL,
57079
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_LABEL,
57080
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
57081
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
57082
      (void*)&&ZEND_NULL_LABEL,
57083
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_LABEL,
57084
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_LABEL,
57085
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
57086
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
57087
      (void*)&&ZEND_NULL_LABEL,
57088
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_LABEL,
57089
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_LABEL,
57090
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
57091
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
57092
      (void*)&&ZEND_NULL_LABEL,
57093
      (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_LABEL,
57094
      (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CONST_LABEL,
57095
      (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
57096
      (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
57097
      (void*)&&ZEND_NULL_LABEL,
57098
      (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CV_LABEL,
57099
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57100
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57101
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57102
      (void*)&&ZEND_NULL_LABEL,
57103
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57104
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57105
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57106
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57107
      (void*)&&ZEND_NULL_LABEL,
57108
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57109
      (void*)&&ZEND_NULL_LABEL,
57110
      (void*)&&ZEND_NULL_LABEL,
57111
      (void*)&&ZEND_NULL_LABEL,
57112
      (void*)&&ZEND_NULL_LABEL,
57113
      (void*)&&ZEND_NULL_LABEL,
57114
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57115
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57116
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57117
      (void*)&&ZEND_NULL_LABEL,
57118
      (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57119
      (void*)&&ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_LABEL,
57120
      (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
57121
      (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
57122
      (void*)&&ZEND_NULL_LABEL,
57123
      (void*)&&ZEND_NULL_LABEL,
57124
      (void*)&&ZEND_NULL_LABEL,
57125
      (void*)&&ZEND_NULL_LABEL,
57126
      (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_LABEL,
57127
      (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_LABEL,
57128
      (void*)&&ZEND_NULL_LABEL,
57129
      (void*)&&ZEND_NULL_LABEL,
57130
      (void*)&&ZEND_EXT_STMT_SPEC_LABEL,
57131
      (void*)&&ZEND_EXT_FCALL_BEGIN_SPEC_LABEL,
57132
      (void*)&&ZEND_EXT_FCALL_END_SPEC_LABEL,
57133
      (void*)&&ZEND_EXT_NOP_SPEC_LABEL,
57134
      (void*)&&ZEND_TICKS_SPEC_LABEL,
57135
      (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_LABEL,
57136
      (void*)&&ZEND_NULL_LABEL,
57137
      (void*)&&ZEND_NULL_LABEL,
57138
      (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_LABEL,
57139
      (void*)&&ZEND_NULL_LABEL,
57140
      (void*)&&ZEND_CATCH_SPEC_CONST_LABEL,
57141
      (void*)&&ZEND_THROW_SPEC_CONST_LABEL,
57142
      (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
57143
      (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
57144
      (void*)&&ZEND_NULL_LABEL,
57145
      (void*)&&ZEND_THROW_SPEC_CV_LABEL,
57146
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_LABEL,
57147
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
57148
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
57149
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57150
      (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CV_LABEL,
57151
      (void*)&&ZEND_CLONE_SPEC_CONST_LABEL,
57152
      (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
57153
      (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
57154
      (void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL,
57155
      (void*)&&ZEND_CLONE_SPEC_CV_LABEL,
57156
      (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL,
57157
      (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57158
      (void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_LABEL,
57159
      (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57160
      (void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_LABEL,
57161
      (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57162
      (void*)&&ZEND_NULL_LABEL,
57163
      (void*)&&ZEND_NULL_LABEL,
57164
      (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL,
57165
      (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57166
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL,
57167
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57168
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57169
      (void*)&&ZEND_NULL_LABEL,
57170
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL,
57171
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
57172
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57173
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57174
      (void*)&&ZEND_NULL_LABEL,
57175
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
57176
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
57177
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57178
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57179
      (void*)&&ZEND_NULL_LABEL,
57180
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
57181
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
57182
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57183
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57184
      (void*)&&ZEND_NULL_LABEL,
57185
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
57186
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL,
57187
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
57188
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
57189
      (void*)&&ZEND_NULL_LABEL,
57190
      (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL,
57191
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL,
57192
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57193
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57194
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL,
57195
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL,
57196
      (void*)&&ZEND_NULL_LABEL,
57197
      (void*)&&ZEND_NULL_LABEL,
57198
      (void*)&&ZEND_NULL_LABEL,
57199
      (void*)&&ZEND_NULL_LABEL,
57200
      (void*)&&ZEND_NULL_LABEL,
57201
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL,
57202
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
57203
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
57204
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL,
57205
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL,
57206
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
57207
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57208
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57209
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL,
57210
      (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
57211
      (void*)&&ZEND_NULL_LABEL,
57212
      (void*)&&ZEND_NULL_LABEL,
57213
      (void*)&&ZEND_NULL_LABEL,
57214
      (void*)&&ZEND_NULL_LABEL,
57215
      (void*)&&ZEND_NULL_LABEL,
57216
      (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_LABEL,
57217
      (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
57218
      (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
57219
      (void*)&&ZEND_NULL_LABEL,
57220
      (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_LABEL,
57221
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_LABEL,
57222
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
57223
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
57224
      (void*)&&ZEND_NULL_LABEL,
57225
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_LABEL,
57226
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
57227
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57228
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57229
      (void*)&&ZEND_NULL_LABEL,
57230
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
57231
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
57232
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57233
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57234
      (void*)&&ZEND_NULL_LABEL,
57235
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
57236
      (void*)&&ZEND_NULL_LABEL,
57237
      (void*)&&ZEND_NULL_LABEL,
57238
      (void*)&&ZEND_NULL_LABEL,
57239
      (void*)&&ZEND_NULL_LABEL,
57240
      (void*)&&ZEND_NULL_LABEL,
57241
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_LABEL,
57242
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
57243
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
57244
      (void*)&&ZEND_NULL_LABEL,
57245
      (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_LABEL,
57246
      (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
57247
      (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
57248
      (void*)&&ZEND_NULL_LABEL,
57249
      (void*)&&ZEND_NULL_LABEL,
57250
      (void*)&&ZEND_NULL_LABEL,
57251
      (void*)&&ZEND_NULL_LABEL,
57252
      (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_LABEL,
57253
      (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_LABEL,
57254
      (void*)&&ZEND_NULL_LABEL,
57255
      (void*)&&ZEND_NULL_LABEL,
57256
      (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
57257
      (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
57258
      (void*)&&ZEND_NULL_LABEL,
57259
      (void*)&&ZEND_NULL_LABEL,
57260
      (void*)&&ZEND_NULL_LABEL,
57261
      (void*)&&ZEND_NULL_LABEL,
57262
      (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_LABEL,
57263
      (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_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_NULL_LABEL,
57299
      (void*)&&ZEND_NULL_LABEL,
57300
      (void*)&&ZEND_NULL_LABEL,
57301
      (void*)&&ZEND_NULL_LABEL,
57302
      (void*)&&ZEND_NULL_LABEL,
57303
      (void*)&&ZEND_NULL_LABEL,
57304
      (void*)&&ZEND_NULL_LABEL,
57305
      (void*)&&ZEND_NULL_LABEL,
57306
      (void*)&&ZEND_SEND_VAR_SPEC_VAR_CONST_LABEL,
57307
      (void*)&&ZEND_NULL_LABEL,
57308
      (void*)&&ZEND_NULL_LABEL,
57309
      (void*)&&ZEND_SEND_VAR_SPEC_VAR_UNUSED_LABEL,
57310
      (void*)&&ZEND_NULL_LABEL,
57311
      (void*)&&ZEND_NULL_LABEL,
57312
      (void*)&&ZEND_NULL_LABEL,
57313
      (void*)&&ZEND_NULL_LABEL,
57314
      (void*)&&ZEND_NULL_LABEL,
57315
      (void*)&&ZEND_NULL_LABEL,
57316
      (void*)&&ZEND_SEND_VAR_SPEC_CV_CONST_LABEL,
57317
      (void*)&&ZEND_NULL_LABEL,
57318
      (void*)&&ZEND_NULL_LABEL,
57319
      (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL,
57320
      (void*)&&ZEND_NULL_LABEL,
57321
      (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL,
57322
      (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
57323
      (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
57324
      (void*)&&ZEND_NULL_LABEL,
57325
      (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL,
57326
      (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL,
57327
      (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL,
57328
      (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL,
57329
      (void*)&&ZEND_SEND_USER_SPEC_VAR_LABEL,
57330
      (void*)&&ZEND_NULL_LABEL,
57331
      (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL,
57332
      (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL,
57333
      (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
57334
      (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
57335
      (void*)&&ZEND_NULL_LABEL,
57336
      (void*)&&ZEND_STRLEN_SPEC_CV_LABEL,
57337
      (void*)&&ZEND_DEFINED_SPEC_CONST_LABEL,
57338
      (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_LABEL,
57339
      (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
57340
      (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
57341
      (void*)&&ZEND_NULL_LABEL,
57342
      (void*)&&ZEND_TYPE_CHECK_SPEC_CV_LABEL,
57343
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL,
57344
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_LABEL,
57345
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_LABEL,
57346
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_LABEL,
57347
      (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_LABEL,
57348
      (void*)&&ZEND_FE_RESET_RW_SPEC_CONST_LABEL,
57349
      (void*)&&ZEND_FE_RESET_RW_SPEC_TMP_LABEL,
57350
      (void*)&&ZEND_FE_RESET_RW_SPEC_VAR_LABEL,
57351
      (void*)&&ZEND_NULL_LABEL,
57352
      (void*)&&ZEND_FE_RESET_RW_SPEC_CV_LABEL,
57353
      (void*)&&ZEND_FE_FETCH_RW_SPEC_VAR_LABEL,
57354
      (void*)&&ZEND_FE_FREE_SPEC_TMPVAR_LABEL,
57355
      (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_LABEL,
57356
      (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
57357
      (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
57358
      (void*)&&ZEND_NULL_LABEL,
57359
      (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CV_LABEL,
57360
      (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_LABEL,
57361
      (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL,
57362
      (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
57363
      (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
57364
      (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL,
57365
      (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL,
57366
      (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
57367
      (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
57368
      (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_LABEL,
57369
      (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_LABEL,
57370
      (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
57371
      (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
57372
      (void*)&&ZEND_NULL_LABEL,
57373
      (void*)&&ZEND_NULL_LABEL,
57374
      (void*)&&ZEND_NULL_LABEL,
57375
      (void*)&&ZEND_NULL_LABEL,
57376
      (void*)&&ZEND_NULL_LABEL,
57377
      (void*)&&ZEND_NULL_LABEL,
57378
      (void*)&&ZEND_NULL_LABEL,
57379
      (void*)&&ZEND_NULL_LABEL,
57380
      (void*)&&ZEND_NULL_LABEL,
57381
      (void*)&&ZEND_NULL_LABEL,
57382
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_LABEL,
57383
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57384
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57385
      (void*)&&ZEND_NULL_LABEL,
57386
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CV_LABEL,
57387
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
57388
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57389
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57390
      (void*)&&ZEND_NULL_LABEL,
57391
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_LABEL,
57392
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CONST_LABEL,
57393
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57394
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57395
      (void*)&&ZEND_NULL_LABEL,
57396
      (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CV_LABEL,
57397
      (void*)&&ZEND_NULL_LABEL,
57398
      (void*)&&ZEND_NULL_LABEL,
57399
      (void*)&&ZEND_NULL_LABEL,
57400
      (void*)&&ZEND_NULL_LABEL,
57401
      (void*)&&ZEND_NULL_LABEL,
57402
      (void*)&&ZEND_NULL_LABEL,
57403
      (void*)&&ZEND_NULL_LABEL,
57404
      (void*)&&ZEND_NULL_LABEL,
57405
      (void*)&&ZEND_NULL_LABEL,
57406
      (void*)&&ZEND_NULL_LABEL,
57407
      (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CONST_LABEL,
57408
      (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57409
      (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57410
      (void*)&&ZEND_NULL_LABEL,
57411
      (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CV_LABEL,
57412
      (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
57413
      (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57414
      (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57415
      (void*)&&ZEND_NULL_LABEL,
57416
      (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_LABEL,
57417
      (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CONST_LABEL,
57418
      (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57419
      (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57420
      (void*)&&ZEND_NULL_LABEL,
57421
      (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CV_LABEL,
57422
      (void*)&&ZEND_ECHO_SPEC_CONST_LABEL,
57423
      (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
57424
      (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
57425
      (void*)&&ZEND_NULL_LABEL,
57426
      (void*)&&ZEND_ECHO_SPEC_CV_LABEL,
57427
      (void*)&&ZEND_NULL_LABEL,
57428
      (void*)&&ZEND_NULL_LABEL,
57429
      (void*)&&ZEND_NULL_LABEL,
57430
      (void*)&&ZEND_NULL_LABEL,
57431
      (void*)&&ZEND_NULL_LABEL,
57432
      (void*)&&ZEND_NULL_LABEL,
57433
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
57434
      (void*)&&ZEND_NULL_LABEL,
57435
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
57436
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
57437
      (void*)&&ZEND_NULL_LABEL,
57438
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
57439
      (void*)&&ZEND_NULL_LABEL,
57440
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
57441
      (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
57442
      (void*)&&ZEND_NULL_LABEL,
57443
      (void*)&&ZEND_NULL_LABEL,
57444
      (void*)&&ZEND_NULL_LABEL,
57445
      (void*)&&ZEND_NULL_LABEL,
57446
      (void*)&&ZEND_NULL_LABEL,
57447
      (void*)&&ZEND_NULL_LABEL,
57448
      (void*)&&ZEND_INSTANCEOF_SPEC_CV_CONST_LABEL,
57449
      (void*)&&ZEND_NULL_LABEL,
57450
      (void*)&&ZEND_INSTANCEOF_SPEC_CV_VAR_LABEL,
57451
      (void*)&&ZEND_INSTANCEOF_SPEC_CV_UNUSED_LABEL,
57452
      (void*)&&ZEND_NULL_LABEL,
57453
      (void*)&&ZEND_GENERATOR_CREATE_SPEC_LABEL,
57454
      (void*)&&ZEND_NULL_LABEL,
57455
      (void*)&&ZEND_NULL_LABEL,
57456
      (void*)&&ZEND_MAKE_REF_SPEC_VAR_UNUSED_LABEL,
57457
      (void*)&&ZEND_NULL_LABEL,
57458
      (void*)&&ZEND_MAKE_REF_SPEC_CV_UNUSED_LABEL,
57459
      (void*)&&ZEND_DECLARE_FUNCTION_SPEC_LABEL,
57460
      (void*)&&ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_LABEL,
57461
      (void*)&&ZEND_DECLARE_CONST_SPEC_CONST_CONST_LABEL,
57462
      (void*)&&ZEND_DECLARE_CLASS_SPEC_CONST_LABEL,
57463
      (void*)&&ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_LABEL,
57464
      (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL,
57465
      (void*)&&ZEND_ADD_ARRAY_UNPACK_SPEC_LABEL,
57466
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_LABEL,
57467
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
57468
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
57469
      (void*)&&ZEND_NULL_LABEL,
57470
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_LABEL,
57471
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
57472
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57473
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57474
      (void*)&&ZEND_NULL_LABEL,
57475
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
57476
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
57477
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57478
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57479
      (void*)&&ZEND_NULL_LABEL,
57480
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
57481
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_LABEL,
57482
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57483
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57484
      (void*)&&ZEND_NULL_LABEL,
57485
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_LABEL,
57486
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_LABEL,
57487
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
57488
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
57489
      (void*)&&ZEND_NULL_LABEL,
57490
      (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL,
57491
      (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL,
57492
      (void*)&&ZEND_USER_OPCODE_SPEC_LABEL,
57493
      (void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL,
57494
      (void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL,
57495
      (void*)&&ZEND_JMP_SET_SPEC_TMP_LABEL,
57496
      (void*)&&ZEND_JMP_SET_SPEC_VAR_LABEL,
57497
      (void*)&&ZEND_NULL_LABEL,
57498
      (void*)&&ZEND_JMP_SET_SPEC_CV_LABEL,
57499
      (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
57500
      (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL,
57501
      (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL,
57502
      (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL,
57503
      (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
57504
      (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
57505
      (void*)&&ZEND_NULL_LABEL,
57506
      (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
57507
      (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL,
57508
      (void*)&&ZEND_NULL_LABEL,
57509
      (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
57510
      (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
57511
      (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
57512
      (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL,
57513
      (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
57514
      (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL,
57515
      (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL,
57516
      (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL,
57517
      (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
57518
      (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
57519
      (void*)&&ZEND_YIELD_SPEC_CONST_UNUSED_LABEL,
57520
      (void*)&&ZEND_YIELD_SPEC_CONST_CV_LABEL,
57521
      (void*)&&ZEND_YIELD_SPEC_TMP_CONST_LABEL,
57522
      (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
57523
      (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
57524
      (void*)&&ZEND_YIELD_SPEC_TMP_UNUSED_LABEL,
57525
      (void*)&&ZEND_YIELD_SPEC_TMP_CV_LABEL,
57526
      (void*)&&ZEND_YIELD_SPEC_VAR_CONST_LABEL,
57527
      (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
57528
      (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
57529
      (void*)&&ZEND_YIELD_SPEC_VAR_UNUSED_LABEL,
57530
      (void*)&&ZEND_YIELD_SPEC_VAR_CV_LABEL,
57531
      (void*)&&ZEND_YIELD_SPEC_UNUSED_CONST_LABEL,
57532
      (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
57533
      (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
57534
      (void*)&&ZEND_YIELD_SPEC_UNUSED_UNUSED_LABEL,
57535
      (void*)&&ZEND_YIELD_SPEC_UNUSED_CV_LABEL,
57536
      (void*)&&ZEND_YIELD_SPEC_CV_CONST_LABEL,
57537
      (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
57538
      (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
57539
      (void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL,
57540
      (void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL,
57541
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL,
57542
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57543
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_LABEL,
57544
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57545
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_LABEL,
57546
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57547
      (void*)&&ZEND_NULL_LABEL,
57548
      (void*)&&ZEND_NULL_LABEL,
57549
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL,
57550
      (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57551
      (void*)&&ZEND_FAST_CALL_SPEC_LABEL,
57552
      (void*)&&ZEND_FAST_RET_SPEC_LABEL,
57553
      (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL,
57554
      (void*)&&ZEND_SEND_UNPACK_SPEC_LABEL,
57555
      (void*)&&ZEND_YIELD_FROM_SPEC_CONST_LABEL,
57556
      (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
57557
      (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
57558
      (void*)&&ZEND_NULL_LABEL,
57559
      (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL,
57560
      (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL,
57561
      (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL,
57562
      (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL,
57563
      (void*)&&ZEND_COALESCE_SPEC_TMP_LABEL,
57564
      (void*)&&ZEND_COALESCE_SPEC_VAR_LABEL,
57565
      (void*)&&ZEND_NULL_LABEL,
57566
      (void*)&&ZEND_COALESCE_SPEC_CV_LABEL,
57567
      (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL,
57568
      (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
57569
      (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
57570
      (void*)&&ZEND_NULL_LABEL,
57571
      (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL,
57572
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
57573
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57574
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57575
      (void*)&&ZEND_NULL_LABEL,
57576
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
57577
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
57578
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57579
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57580
      (void*)&&ZEND_NULL_LABEL,
57581
      (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
57582
      (void*)&&ZEND_NULL_LABEL,
57583
      (void*)&&ZEND_NULL_LABEL,
57584
      (void*)&&ZEND_NULL_LABEL,
57585
      (void*)&&ZEND_NULL_LABEL,
57586
      (void*)&&ZEND_NULL_LABEL,
57587
      (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL,
57588
      (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
57589
      (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
57590
      (void*)&&ZEND_NULL_LABEL,
57591
      (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL,
57592
      (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57593
      (void*)&&ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_LABEL,
57594
      (void*)&&ZEND_NULL_LABEL,
57595
      (void*)&&ZEND_NULL_LABEL,
57596
      (void*)&&ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57597
      (void*)&&ZEND_NULL_LABEL,
57598
      (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_LABEL,
57599
      (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_LABEL,
57600
      (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_LABEL,
57601
      (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_LABEL,
57602
      (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_LABEL,
57603
      (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_LABEL,
57604
      (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_LABEL,
57605
      (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_LABEL,
57606
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_LABEL,
57607
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57608
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57609
      (void*)&&ZEND_NULL_LABEL,
57610
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57611
      (void*)&&ZEND_NULL_LABEL,
57612
      (void*)&&ZEND_NULL_LABEL,
57613
      (void*)&&ZEND_NULL_LABEL,
57614
      (void*)&&ZEND_NULL_LABEL,
57615
      (void*)&&ZEND_NULL_LABEL,
57616
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_LABEL,
57617
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57618
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57619
      (void*)&&ZEND_NULL_LABEL,
57620
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57621
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_LABEL,
57622
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57623
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57624
      (void*)&&ZEND_NULL_LABEL,
57625
      (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57626
      (void*)&&ZEND_NULL_LABEL,
57627
      (void*)&&ZEND_NULL_LABEL,
57628
      (void*)&&ZEND_NULL_LABEL,
57629
      (void*)&&ZEND_NULL_LABEL,
57630
      (void*)&&ZEND_NULL_LABEL,
57631
      (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL,
57632
      (void*)&&ZEND_BIND_STATIC_SPEC_CV_LABEL,
57633
      (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL,
57634
      (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_LABEL,
57635
      (void*)&&ZEND_NULL_LABEL,
57636
      (void*)&&ZEND_NULL_LABEL,
57637
      (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
57638
      (void*)&&ZEND_NULL_LABEL,
57639
      (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL,
57640
      (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL,
57641
      (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57642
      (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57643
      (void*)&&ZEND_NULL_LABEL,
57644
      (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57645
      (void*)&&ZEND_SWITCH_STRING_SPEC_CONST_CONST_LABEL,
57646
      (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57647
      (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57648
      (void*)&&ZEND_NULL_LABEL,
57649
      (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57650
      (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL,
57651
      (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL,
57652
      (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL,
57653
      (void*)&&ZEND_NULL_LABEL,
57654
      (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL,
57655
      (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL,
57656
      (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
57657
      (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
57658
      (void*)&&ZEND_NULL_LABEL,
57659
      (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL,
57660
      (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL,
57661
      (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
57662
      (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
57663
      (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57664
      (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL,
57665
      (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57666
      (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL,
57667
      (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL,
57668
      (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL,
57669
      (void*)&&ZEND_NULL_LABEL,
57670
      (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL,
57671
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
57672
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
57673
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
57674
      (void*)&&ZEND_NULL_LABEL,
57675
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
57676
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
57677
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57678
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57679
      (void*)&&ZEND_NULL_LABEL,
57680
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
57681
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
57682
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57683
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57684
      (void*)&&ZEND_NULL_LABEL,
57685
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
57686
      (void*)&&ZEND_NULL_LABEL,
57687
      (void*)&&ZEND_NULL_LABEL,
57688
      (void*)&&ZEND_NULL_LABEL,
57689
      (void*)&&ZEND_NULL_LABEL,
57690
      (void*)&&ZEND_NULL_LABEL,
57691
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
57692
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
57693
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
57694
      (void*)&&ZEND_NULL_LABEL,
57695
      (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
57696
      (void*)&&ZEND_MATCH_SPEC_CONST_CONST_LABEL,
57697
      (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57698
      (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57699
      (void*)&&ZEND_NULL_LABEL,
57700
      (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57701
      (void*)&&ZEND_NULL_LABEL,
57702
      (void*)&&ZEND_NULL_LABEL,
57703
      (void*)&&ZEND_NULL_LABEL,
57704
      (void*)&&ZEND_NULL_LABEL,
57705
      (void*)&&ZEND_NULL_LABEL,
57706
      (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CONST_LABEL,
57707
      (void*)&&ZEND_CASE_STRICT_SPEC_TMP_TMP_LABEL,
57708
      (void*)&&ZEND_CASE_STRICT_SPEC_TMP_VAR_LABEL,
57709
      (void*)&&ZEND_NULL_LABEL,
57710
      (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CV_LABEL,
57711
      (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CONST_LABEL,
57712
      (void*)&&ZEND_CASE_STRICT_SPEC_VAR_TMP_LABEL,
57713
      (void*)&&ZEND_CASE_STRICT_SPEC_VAR_VAR_LABEL,
57714
      (void*)&&ZEND_NULL_LABEL,
57715
      (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CV_LABEL,
57716
      (void*)&&ZEND_NULL_LABEL,
57717
      (void*)&&ZEND_NULL_LABEL,
57718
      (void*)&&ZEND_NULL_LABEL,
57719
      (void*)&&ZEND_NULL_LABEL,
57720
      (void*)&&ZEND_NULL_LABEL,
57721
      (void*)&&ZEND_NULL_LABEL,
57722
      (void*)&&ZEND_NULL_LABEL,
57723
      (void*)&&ZEND_NULL_LABEL,
57724
      (void*)&&ZEND_NULL_LABEL,
57725
      (void*)&&ZEND_NULL_LABEL,
57726
      (void*)&&ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_LABEL,
57727
      (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57728
      (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57729
      (void*)&&ZEND_NULL_LABEL,
57730
      (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57731
      (void*)&&ZEND_JMP_NULL_SPEC_CONST_LABEL,
57732
      (void*)&&ZEND_JMP_NULL_SPEC_TMP_LABEL,
57733
      (void*)&&ZEND_JMP_NULL_SPEC_VAR_LABEL,
57734
      (void*)&&ZEND_NULL_LABEL,
57735
      (void*)&&ZEND_JMP_NULL_SPEC_CV_LABEL,
57736
      (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57737
      (void*)&&ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_LABEL,
57738
      (void*)&&ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_LABEL,
57739
      (void*)&&ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_LABEL,
57740
      (void*)&&ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_LABEL,
57741
      (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_LABEL,
57742
      (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_LABEL,
57743
      (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_LABEL,
57744
      (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_LABEL,
57745
      (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_LABEL,
57746
      (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_LABEL,
57747
      (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_LABEL,
57748
      (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_LABEL,
57749
      (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
57750
      (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL,
57751
      (void*)&&ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_LABEL,
57752
      (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
57753
      (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
57754
      (void*)&&ZEND_NULL_LABEL,
57755
      (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
57756
      (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
57757
      (void*)&&ZEND_NULL_LABEL,
57758
      (void*)&&ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_LABEL,
57759
      (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
57760
      (void*)&&ZEND_NULL_LABEL,
57761
      (void*)&&ZEND_NULL_LABEL,
57762
      (void*)&&ZEND_NULL_LABEL,
57763
      (void*)&&ZEND_NULL_LABEL,
57764
      (void*)&&ZEND_NULL_LABEL,
57765
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57766
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57767
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57768
      (void*)&&ZEND_NULL_LABEL,
57769
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57770
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57771
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57772
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57773
      (void*)&&ZEND_NULL_LABEL,
57774
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57775
      (void*)&&ZEND_NULL_LABEL,
57776
      (void*)&&ZEND_NULL_LABEL,
57777
      (void*)&&ZEND_NULL_LABEL,
57778
      (void*)&&ZEND_NULL_LABEL,
57779
      (void*)&&ZEND_NULL_LABEL,
57780
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57781
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57782
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57783
      (void*)&&ZEND_NULL_LABEL,
57784
      (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57785
      (void*)&&ZEND_NULL_LABEL,
57786
      (void*)&&ZEND_NULL_LABEL,
57787
      (void*)&&ZEND_NULL_LABEL,
57788
      (void*)&&ZEND_NULL_LABEL,
57789
      (void*)&&ZEND_NULL_LABEL,
57790
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57791
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57792
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57793
      (void*)&&ZEND_NULL_LABEL,
57794
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57795
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57796
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57797
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57798
      (void*)&&ZEND_NULL_LABEL,
57799
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57800
      (void*)&&ZEND_NULL_LABEL,
57801
      (void*)&&ZEND_NULL_LABEL,
57802
      (void*)&&ZEND_NULL_LABEL,
57803
      (void*)&&ZEND_NULL_LABEL,
57804
      (void*)&&ZEND_NULL_LABEL,
57805
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57806
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57807
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57808
      (void*)&&ZEND_NULL_LABEL,
57809
      (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57810
      (void*)&&ZEND_NULL_LABEL,
57811
      (void*)&&ZEND_NULL_LABEL,
57812
      (void*)&&ZEND_NULL_LABEL,
57813
      (void*)&&ZEND_NULL_LABEL,
57814
      (void*)&&ZEND_NULL_LABEL,
57815
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57816
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57817
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57818
      (void*)&&ZEND_NULL_LABEL,
57819
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57820
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57821
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57822
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57823
      (void*)&&ZEND_NULL_LABEL,
57824
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57825
      (void*)&&ZEND_NULL_LABEL,
57826
      (void*)&&ZEND_NULL_LABEL,
57827
      (void*)&&ZEND_NULL_LABEL,
57828
      (void*)&&ZEND_NULL_LABEL,
57829
      (void*)&&ZEND_NULL_LABEL,
57830
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57831
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57832
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57833
      (void*)&&ZEND_NULL_LABEL,
57834
      (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57835
      (void*)&&ZEND_NULL_LABEL,
57836
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57837
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57838
      (void*)&&ZEND_NULL_LABEL,
57839
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57840
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57841
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57842
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57843
      (void*)&&ZEND_NULL_LABEL,
57844
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57845
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57846
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57847
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57848
      (void*)&&ZEND_NULL_LABEL,
57849
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57850
      (void*)&&ZEND_NULL_LABEL,
57851
      (void*)&&ZEND_NULL_LABEL,
57852
      (void*)&&ZEND_NULL_LABEL,
57853
      (void*)&&ZEND_NULL_LABEL,
57854
      (void*)&&ZEND_NULL_LABEL,
57855
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57856
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57857
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57858
      (void*)&&ZEND_NULL_LABEL,
57859
      (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57860
      (void*)&&ZEND_NULL_LABEL,
57861
      (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57862
      (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57863
      (void*)&&ZEND_NULL_LABEL,
57864
      (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57865
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57866
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57867
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57868
      (void*)&&ZEND_NULL_LABEL,
57869
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57870
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57871
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57872
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57873
      (void*)&&ZEND_NULL_LABEL,
57874
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57875
      (void*)&&ZEND_NULL_LABEL,
57876
      (void*)&&ZEND_NULL_LABEL,
57877
      (void*)&&ZEND_NULL_LABEL,
57878
      (void*)&&ZEND_NULL_LABEL,
57879
      (void*)&&ZEND_NULL_LABEL,
57880
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57881
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57882
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57883
      (void*)&&ZEND_NULL_LABEL,
57884
      (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57885
      (void*)&&ZEND_NULL_LABEL,
57886
      (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57887
      (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57888
      (void*)&&ZEND_NULL_LABEL,
57889
      (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57890
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57891
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57892
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57893
      (void*)&&ZEND_NULL_LABEL,
57894
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57895
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57896
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57897
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57898
      (void*)&&ZEND_NULL_LABEL,
57899
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57900
      (void*)&&ZEND_NULL_LABEL,
57901
      (void*)&&ZEND_NULL_LABEL,
57902
      (void*)&&ZEND_NULL_LABEL,
57903
      (void*)&&ZEND_NULL_LABEL,
57904
      (void*)&&ZEND_NULL_LABEL,
57905
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57906
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57907
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57908
      (void*)&&ZEND_NULL_LABEL,
57909
      (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57910
      (void*)&&ZEND_NULL_LABEL,
57911
      (void*)&&ZEND_NULL_LABEL,
57912
      (void*)&&ZEND_NULL_LABEL,
57913
      (void*)&&ZEND_NULL_LABEL,
57914
      (void*)&&ZEND_NULL_LABEL,
57915
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57916
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57917
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57918
      (void*)&&ZEND_NULL_LABEL,
57919
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57920
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57921
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57922
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57923
      (void*)&&ZEND_NULL_LABEL,
57924
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57925
      (void*)&&ZEND_NULL_LABEL,
57926
      (void*)&&ZEND_NULL_LABEL,
57927
      (void*)&&ZEND_NULL_LABEL,
57928
      (void*)&&ZEND_NULL_LABEL,
57929
      (void*)&&ZEND_NULL_LABEL,
57930
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57931
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57932
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57933
      (void*)&&ZEND_NULL_LABEL,
57934
      (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57935
      (void*)&&ZEND_NULL_LABEL,
57936
      (void*)&&ZEND_NULL_LABEL,
57937
      (void*)&&ZEND_NULL_LABEL,
57938
      (void*)&&ZEND_NULL_LABEL,
57939
      (void*)&&ZEND_NULL_LABEL,
57940
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57941
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57942
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57943
      (void*)&&ZEND_NULL_LABEL,
57944
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57945
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57946
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57947
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57948
      (void*)&&ZEND_NULL_LABEL,
57949
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57950
      (void*)&&ZEND_NULL_LABEL,
57951
      (void*)&&ZEND_NULL_LABEL,
57952
      (void*)&&ZEND_NULL_LABEL,
57953
      (void*)&&ZEND_NULL_LABEL,
57954
      (void*)&&ZEND_NULL_LABEL,
57955
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57956
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57957
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57958
      (void*)&&ZEND_NULL_LABEL,
57959
      (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57960
      (void*)&&ZEND_NULL_LABEL,
57961
      (void*)&&ZEND_NULL_LABEL,
57962
      (void*)&&ZEND_NULL_LABEL,
57963
      (void*)&&ZEND_NULL_LABEL,
57964
      (void*)&&ZEND_NULL_LABEL,
57965
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57966
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57967
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57968
      (void*)&&ZEND_NULL_LABEL,
57969
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57970
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57971
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57972
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57973
      (void*)&&ZEND_NULL_LABEL,
57974
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57975
      (void*)&&ZEND_NULL_LABEL,
57976
      (void*)&&ZEND_NULL_LABEL,
57977
      (void*)&&ZEND_NULL_LABEL,
57978
      (void*)&&ZEND_NULL_LABEL,
57979
      (void*)&&ZEND_NULL_LABEL,
57980
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57981
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57982
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57983
      (void*)&&ZEND_NULL_LABEL,
57984
      (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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_NULL_LABEL,
57993
      (void*)&&ZEND_NULL_LABEL,
57994
      (void*)&&ZEND_NULL_LABEL,
57995
      (void*)&&ZEND_NULL_LABEL,
57996
      (void*)&&ZEND_NULL_LABEL,
57997
      (void*)&&ZEND_NULL_LABEL,
57998
      (void*)&&ZEND_NULL_LABEL,
57999
      (void*)&&ZEND_NULL_LABEL,
58000
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58001
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58002
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58003
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58004
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58005
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58006
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58007
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58008
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58009
      (void*)&&ZEND_NULL_LABEL,
58010
      (void*)&&ZEND_NULL_LABEL,
58011
      (void*)&&ZEND_NULL_LABEL,
58012
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58013
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58014
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58015
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58016
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58017
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58018
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58019
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58020
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58021
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58022
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58023
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58024
      (void*)&&ZEND_NULL_LABEL,
58025
      (void*)&&ZEND_NULL_LABEL,
58026
      (void*)&&ZEND_NULL_LABEL,
58027
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58028
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58029
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58038
      (void*)&&ZEND_NULL_LABEL,
58039
      (void*)&&ZEND_NULL_LABEL,
58040
      (void*)&&ZEND_NULL_LABEL,
58041
      (void*)&&ZEND_NULL_LABEL,
58042
      (void*)&&ZEND_NULL_LABEL,
58043
      (void*)&&ZEND_NULL_LABEL,
58044
      (void*)&&ZEND_NULL_LABEL,
58045
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58046
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58047
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58048
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58049
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58050
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58051
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58052
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58053
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58054
      (void*)&&ZEND_NULL_LABEL,
58055
      (void*)&&ZEND_NULL_LABEL,
58056
      (void*)&&ZEND_NULL_LABEL,
58057
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58058
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58059
      (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58068
      (void*)&&ZEND_NULL_LABEL,
58069
      (void*)&&ZEND_NULL_LABEL,
58070
      (void*)&&ZEND_NULL_LABEL,
58071
      (void*)&&ZEND_NULL_LABEL,
58072
      (void*)&&ZEND_NULL_LABEL,
58073
      (void*)&&ZEND_NULL_LABEL,
58074
      (void*)&&ZEND_NULL_LABEL,
58075
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58076
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58077
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58078
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58079
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58080
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58081
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58082
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58083
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58084
      (void*)&&ZEND_NULL_LABEL,
58085
      (void*)&&ZEND_NULL_LABEL,
58086
      (void*)&&ZEND_NULL_LABEL,
58087
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58088
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58089
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58090
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58091
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58092
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58093
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58094
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58095
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58096
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58097
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58098
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58099
      (void*)&&ZEND_NULL_LABEL,
58100
      (void*)&&ZEND_NULL_LABEL,
58101
      (void*)&&ZEND_NULL_LABEL,
58102
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58103
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58104
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58113
      (void*)&&ZEND_NULL_LABEL,
58114
      (void*)&&ZEND_NULL_LABEL,
58115
      (void*)&&ZEND_NULL_LABEL,
58116
      (void*)&&ZEND_NULL_LABEL,
58117
      (void*)&&ZEND_NULL_LABEL,
58118
      (void*)&&ZEND_NULL_LABEL,
58119
      (void*)&&ZEND_NULL_LABEL,
58120
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58121
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58122
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58123
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58124
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58125
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58126
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58127
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58128
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58129
      (void*)&&ZEND_NULL_LABEL,
58130
      (void*)&&ZEND_NULL_LABEL,
58131
      (void*)&&ZEND_NULL_LABEL,
58132
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58133
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58134
      (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58143
      (void*)&&ZEND_NULL_LABEL,
58144
      (void*)&&ZEND_NULL_LABEL,
58145
      (void*)&&ZEND_NULL_LABEL,
58146
      (void*)&&ZEND_NULL_LABEL,
58147
      (void*)&&ZEND_NULL_LABEL,
58148
      (void*)&&ZEND_NULL_LABEL,
58149
      (void*)&&ZEND_NULL_LABEL,
58150
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58151
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58152
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58153
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58154
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58155
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58156
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58157
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58158
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58159
      (void*)&&ZEND_NULL_LABEL,
58160
      (void*)&&ZEND_NULL_LABEL,
58161
      (void*)&&ZEND_NULL_LABEL,
58162
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58163
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58164
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58165
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58166
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58167
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58168
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58169
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58170
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58171
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58172
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58173
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58174
      (void*)&&ZEND_NULL_LABEL,
58175
      (void*)&&ZEND_NULL_LABEL,
58176
      (void*)&&ZEND_NULL_LABEL,
58177
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58178
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58179
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58188
      (void*)&&ZEND_NULL_LABEL,
58189
      (void*)&&ZEND_NULL_LABEL,
58190
      (void*)&&ZEND_NULL_LABEL,
58191
      (void*)&&ZEND_NULL_LABEL,
58192
      (void*)&&ZEND_NULL_LABEL,
58193
      (void*)&&ZEND_NULL_LABEL,
58194
      (void*)&&ZEND_NULL_LABEL,
58195
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58196
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58197
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58198
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58199
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58200
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58201
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58202
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58203
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58204
      (void*)&&ZEND_NULL_LABEL,
58205
      (void*)&&ZEND_NULL_LABEL,
58206
      (void*)&&ZEND_NULL_LABEL,
58207
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58208
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58209
      (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58218
      (void*)&&ZEND_NULL_LABEL,
58219
      (void*)&&ZEND_NULL_LABEL,
58220
      (void*)&&ZEND_NULL_LABEL,
58221
      (void*)&&ZEND_NULL_LABEL,
58222
      (void*)&&ZEND_NULL_LABEL,
58223
      (void*)&&ZEND_NULL_LABEL,
58224
      (void*)&&ZEND_NULL_LABEL,
58225
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58226
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58227
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58228
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58229
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58230
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58231
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58232
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58233
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58234
      (void*)&&ZEND_NULL_LABEL,
58235
      (void*)&&ZEND_NULL_LABEL,
58236
      (void*)&&ZEND_NULL_LABEL,
58237
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58238
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58239
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58240
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58241
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58242
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58243
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58244
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58245
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58246
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58247
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58248
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58249
      (void*)&&ZEND_NULL_LABEL,
58250
      (void*)&&ZEND_NULL_LABEL,
58251
      (void*)&&ZEND_NULL_LABEL,
58252
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58253
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58254
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58263
      (void*)&&ZEND_NULL_LABEL,
58264
      (void*)&&ZEND_NULL_LABEL,
58265
      (void*)&&ZEND_NULL_LABEL,
58266
      (void*)&&ZEND_NULL_LABEL,
58267
      (void*)&&ZEND_NULL_LABEL,
58268
      (void*)&&ZEND_NULL_LABEL,
58269
      (void*)&&ZEND_NULL_LABEL,
58270
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58271
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58272
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58273
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58274
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58275
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58276
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58277
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58278
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58279
      (void*)&&ZEND_NULL_LABEL,
58280
      (void*)&&ZEND_NULL_LABEL,
58281
      (void*)&&ZEND_NULL_LABEL,
58282
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58283
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58284
      (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58285
      (void*)&&ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_LABEL,
58286
      (void*)&&ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58287
      (void*)&&ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58288
      (void*)&&ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_LABEL,
58289
      (void*)&&ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58290
      (void*)&&ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58291
      (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
58292
      (void*)&&ZEND_NULL_LABEL,
58293
      (void*)&&ZEND_NULL_LABEL,
58294
      (void*)&&ZEND_NULL_LABEL,
58295
      (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
58296
      (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
58297
      (void*)&&ZEND_NULL_LABEL,
58298
      (void*)&&ZEND_NULL_LABEL,
58299
      (void*)&&ZEND_NULL_LABEL,
58300
      (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
58301
      (void*)&&ZEND_NULL_LABEL,
58302
      (void*)&&ZEND_NULL_LABEL,
58303
      (void*)&&ZEND_NULL_LABEL,
58304
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58305
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58306
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58307
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58308
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58309
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58310
      (void*)&&ZEND_NULL_LABEL,
58311
      (void*)&&ZEND_NULL_LABEL,
58312
      (void*)&&ZEND_NULL_LABEL,
58313
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58314
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58315
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58316
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58317
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58318
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58319
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58320
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58321
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58322
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58323
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58324
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58325
      (void*)&&ZEND_NULL_LABEL,
58326
      (void*)&&ZEND_NULL_LABEL,
58327
      (void*)&&ZEND_NULL_LABEL,
58328
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58329
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58330
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58331
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58332
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58333
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58334
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58335
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58336
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58337
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58338
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58339
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58340
      (void*)&&ZEND_NULL_LABEL,
58341
      (void*)&&ZEND_NULL_LABEL,
58342
      (void*)&&ZEND_NULL_LABEL,
58343
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58344
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58345
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58354
      (void*)&&ZEND_NULL_LABEL,
58355
      (void*)&&ZEND_NULL_LABEL,
58356
      (void*)&&ZEND_NULL_LABEL,
58357
      (void*)&&ZEND_NULL_LABEL,
58358
      (void*)&&ZEND_NULL_LABEL,
58359
      (void*)&&ZEND_NULL_LABEL,
58360
      (void*)&&ZEND_NULL_LABEL,
58361
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58362
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58363
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58364
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58365
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58366
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58367
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58368
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58369
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58370
      (void*)&&ZEND_NULL_LABEL,
58371
      (void*)&&ZEND_NULL_LABEL,
58372
      (void*)&&ZEND_NULL_LABEL,
58373
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58374
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58375
      (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58376
      (void*)&&ZEND_NULL_LABEL,
58377
      (void*)&&ZEND_NULL_LABEL,
58378
      (void*)&&ZEND_NULL_LABEL,
58379
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58380
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58381
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58382
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58383
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58384
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58385
      (void*)&&ZEND_NULL_LABEL,
58386
      (void*)&&ZEND_NULL_LABEL,
58387
      (void*)&&ZEND_NULL_LABEL,
58388
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58389
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58390
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58391
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58392
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58393
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58394
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58395
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58396
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58397
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58398
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58399
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58400
      (void*)&&ZEND_NULL_LABEL,
58401
      (void*)&&ZEND_NULL_LABEL,
58402
      (void*)&&ZEND_NULL_LABEL,
58403
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58404
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58405
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58406
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58407
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58408
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58409
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58410
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58411
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58412
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58413
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58414
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58415
      (void*)&&ZEND_NULL_LABEL,
58416
      (void*)&&ZEND_NULL_LABEL,
58417
      (void*)&&ZEND_NULL_LABEL,
58418
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58419
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58420
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58429
      (void*)&&ZEND_NULL_LABEL,
58430
      (void*)&&ZEND_NULL_LABEL,
58431
      (void*)&&ZEND_NULL_LABEL,
58432
      (void*)&&ZEND_NULL_LABEL,
58433
      (void*)&&ZEND_NULL_LABEL,
58434
      (void*)&&ZEND_NULL_LABEL,
58435
      (void*)&&ZEND_NULL_LABEL,
58436
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58437
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58438
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58439
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58440
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58441
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58442
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58443
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58444
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58445
      (void*)&&ZEND_NULL_LABEL,
58446
      (void*)&&ZEND_NULL_LABEL,
58447
      (void*)&&ZEND_NULL_LABEL,
58448
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58449
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58450
      (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58451
      (void*)&&ZEND_NULL_LABEL,
58452
      (void*)&&ZEND_NULL_LABEL,
58453
      (void*)&&ZEND_NULL_LABEL,
58454
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58455
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58456
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58457
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58458
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58459
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58460
      (void*)&&ZEND_NULL_LABEL,
58461
      (void*)&&ZEND_NULL_LABEL,
58462
      (void*)&&ZEND_NULL_LABEL,
58463
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58464
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58465
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58466
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58467
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58468
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58469
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58470
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58471
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58472
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58473
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58474
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58475
      (void*)&&ZEND_NULL_LABEL,
58476
      (void*)&&ZEND_NULL_LABEL,
58477
      (void*)&&ZEND_NULL_LABEL,
58478
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58479
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58480
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58481
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58482
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58483
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58484
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58485
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58486
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58487
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58488
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58489
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58490
      (void*)&&ZEND_NULL_LABEL,
58491
      (void*)&&ZEND_NULL_LABEL,
58492
      (void*)&&ZEND_NULL_LABEL,
58493
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58494
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58495
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58504
      (void*)&&ZEND_NULL_LABEL,
58505
      (void*)&&ZEND_NULL_LABEL,
58506
      (void*)&&ZEND_NULL_LABEL,
58507
      (void*)&&ZEND_NULL_LABEL,
58508
      (void*)&&ZEND_NULL_LABEL,
58509
      (void*)&&ZEND_NULL_LABEL,
58510
      (void*)&&ZEND_NULL_LABEL,
58511
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58512
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58513
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58514
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58515
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58516
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58517
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58518
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58519
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58520
      (void*)&&ZEND_NULL_LABEL,
58521
      (void*)&&ZEND_NULL_LABEL,
58522
      (void*)&&ZEND_NULL_LABEL,
58523
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58524
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58525
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58526
      (void*)&&ZEND_NULL_LABEL,
58527
      (void*)&&ZEND_NULL_LABEL,
58528
      (void*)&&ZEND_NULL_LABEL,
58529
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58530
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58531
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58532
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58533
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58534
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58535
      (void*)&&ZEND_NULL_LABEL,
58536
      (void*)&&ZEND_NULL_LABEL,
58537
      (void*)&&ZEND_NULL_LABEL,
58538
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58539
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58540
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58541
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58542
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58543
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58544
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58545
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58546
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58547
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58548
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58549
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58550
      (void*)&&ZEND_NULL_LABEL,
58551
      (void*)&&ZEND_NULL_LABEL,
58552
      (void*)&&ZEND_NULL_LABEL,
58553
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58554
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58555
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58556
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58557
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58558
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58559
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58560
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58561
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58562
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58563
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58564
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58565
      (void*)&&ZEND_NULL_LABEL,
58566
      (void*)&&ZEND_NULL_LABEL,
58567
      (void*)&&ZEND_NULL_LABEL,
58568
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58569
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58570
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
58579
      (void*)&&ZEND_NULL_LABEL,
58580
      (void*)&&ZEND_NULL_LABEL,
58581
      (void*)&&ZEND_NULL_LABEL,
58582
      (void*)&&ZEND_NULL_LABEL,
58583
      (void*)&&ZEND_NULL_LABEL,
58584
      (void*)&&ZEND_NULL_LABEL,
58585
      (void*)&&ZEND_NULL_LABEL,
58586
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58587
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58588
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58589
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58590
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58591
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58592
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58593
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58594
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58595
      (void*)&&ZEND_NULL_LABEL,
58596
      (void*)&&ZEND_NULL_LABEL,
58597
      (void*)&&ZEND_NULL_LABEL,
58598
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58599
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58600
      (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58601
      (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
58602
      (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
58603
      (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
58604
      (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_LABEL,
58605
      (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
58606
      (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
58607
      (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
58608
      (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_LABEL,
58609
      (void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
58610
      (void*)&&ZEND_POST_INC_LONG_SPEC_CV_LABEL,
58611
      (void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
58612
      (void*)&&ZEND_POST_DEC_LONG_SPEC_CV_LABEL,
58613
      (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_CONST_LABEL,
58614
      (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58615
      (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58616
      (void*)&&ZEND_NULL_LABEL,
58617
      (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58618
      (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
58619
      (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58620
      (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58621
      (void*)&&ZEND_NULL_LABEL,
58622
      (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58623
      (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_CONST_LABEL,
58624
      (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58625
      (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58626
      (void*)&&ZEND_NULL_LABEL,
58627
      (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58628
      (void*)&&ZEND_NULL_LABEL,
58629
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58630
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58631
      (void*)&&ZEND_NULL_LABEL,
58632
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58633
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
58634
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58635
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58636
      (void*)&&ZEND_NULL_LABEL,
58637
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58638
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
58639
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58640
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58641
      (void*)&&ZEND_NULL_LABEL,
58642
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58643
      (void*)&&ZEND_NULL_LABEL,
58644
      (void*)&&ZEND_NULL_LABEL,
58645
      (void*)&&ZEND_NULL_LABEL,
58646
      (void*)&&ZEND_NULL_LABEL,
58647
      (void*)&&ZEND_NULL_LABEL,
58648
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_LABEL,
58649
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58650
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58651
      (void*)&&ZEND_NULL_LABEL,
58652
      (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58653
      (void*)&&ZEND_NULL_LABEL,
58654
      (void*)&&ZEND_NULL_LABEL,
58655
      (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_VAR_LABEL,
58656
      (void*)&&ZEND_NULL_LABEL,
58657
      (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_CV_LABEL,
58658
      (void*)&&ZEND_NULL_LABEL,
58659
      (void*)&&ZEND_NULL_LABEL,
58660
      (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_LABEL,
58661
      (void*)&&ZEND_NULL_LABEL,
58662
      (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_LABEL,
58663
      (void*)&&ZEND_SEND_VAL_SIMPLE_SPEC_CONST_LABEL,
58664
      (void*)&&ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_LABEL,
58665
      (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
58666
      (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_LABEL,
58667
      (void*)&&ZEND_NULL_LABEL
58668
    };
58669
    zend_opcode_handlers = (const void **) labels;
58670
    zend_handlers_count = sizeof(labels) / sizeof(void*);
58671
    memset(&hybrid_halt_op, 0, sizeof(hybrid_halt_op));
58672
    hybrid_halt_op.handler = (void*)&&HYBRID_HALT_LABEL;
58673
#ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
58674
    memset(vm_stack_data.hybrid_jit_red_zone, 0, ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE);
58675
#endif
58676
    if (zend_touch_vm_stack_data) {
58677
      zend_touch_vm_stack_data(&vm_stack_data);
58678
    }
58679
    goto HYBRID_HALT_LABEL;
58680
  }
58681
#endif
58682
58683
82.6k
  LOAD_OPLINE();
58684
82.6k
  ZEND_VM_LOOP_INTERRUPT_CHECK();
58685
58686
82.6k
#ifdef ZEND_CHECK_STACK_LIMIT
58687
82.6k
  if (UNEXPECTED(zend_call_stack_overflowed(EG(stack_limit)))) {
58688
2
    zend_call_stack_size_error();
58689
    /* No opline was executed before exception */
58690
2
    EG(opline_before_exception) = NULL;
58691
2
    LOAD_OPLINE();
58692
    /* Fall through to handle exception below. */
58693
2
  }
58694
82.6k
#endif /* ZEND_CHECK_STACK_LIMIT */
58695
58696
3.64M
  while (1) {
58697
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
58698
    HYBRID_SWITCH() {
58699
#else /* ZEND_VM_KIND != ZEND_VM_KIND_HYBRID */
58700
#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
58701
    ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58702
    if (UNEXPECTED(!OPLINE)) {
58703
#else
58704
3.61M
    opline = ((opcode_handler_t)opline->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58705
3.61M
    if (UNEXPECTED(((uintptr_t)opline & ZEND_VM_ENTER_BIT))) {
58706
113k
#endif
58707
113k
#endif /* ZEND_VM_KIND != ZEND_VM_KIND_HYBRID */
58708
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
58709
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC):
58710
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
58711
        ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58712
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
58713
        HYBRID_BREAK();
58714
      HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC):
58715
        VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC)
58716
        ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58717
        VM_TRACE_OP_END(ZEND_PRE_INC_STATIC_PROP_SPEC)
58718
        HYBRID_BREAK();
58719
      HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC):
58720
        VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC)
58721
        ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58722
        VM_TRACE_OP_END(ZEND_POST_INC_STATIC_PROP_SPEC)
58723
        HYBRID_BREAK();
58724
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC):
58725
        VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC)
58726
        ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58727
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_R_SPEC)
58728
        HYBRID_BREAK();
58729
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_W_SPEC):
58730
        VM_TRACE(ZEND_FETCH_STATIC_PROP_W_SPEC)
58731
        ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58732
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_W_SPEC)
58733
        HYBRID_BREAK();
58734
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_RW_SPEC):
58735
        VM_TRACE(ZEND_FETCH_STATIC_PROP_RW_SPEC)
58736
        ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58737
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_RW_SPEC)
58738
        HYBRID_BREAK();
58739
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC):
58740
        VM_TRACE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
58741
        ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58742
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
58743
        HYBRID_BREAK();
58744
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC):
58745
        VM_TRACE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
58746
        ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58747
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
58748
        HYBRID_BREAK();
58749
      HYBRID_CASE(ZEND_FETCH_STATIC_PROP_IS_SPEC):
58750
        VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC)
58751
        ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58752
        VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_IS_SPEC)
58753
        HYBRID_BREAK();
58754
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST):
58755
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
58756
        ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58757
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
58758
        HYBRID_BREAK();
58759
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP):
58760
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
58761
        ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58762
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
58763
        HYBRID_BREAK();
58764
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR):
58765
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
58766
        ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58767
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
58768
        HYBRID_BREAK();
58769
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV):
58770
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
58771
        ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58772
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
58773
        HYBRID_BREAK();
58774
      HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC):
58775
        VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
58776
        ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58777
        VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
58778
        HYBRID_BREAK();
58779
zend_leave_helper_SPEC_LABEL:
58780
{
58781
  zend_execute_data *old_execute_data;
58782
  uint32_t call_info = EX_CALL_INFO();
58783
  SAVE_OPLINE();
58784
58785
  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)) {
58786
    EG(current_execute_data) = EX(prev_execute_data);
58787
    i_free_compiled_variables(execute_data);
58788
58789
#ifdef ZEND_PREFER_RELOAD
58790
    call_info = EX_CALL_INFO();
58791
#endif
58792
    if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
58793
      OBJ_RELEASE(Z_OBJ(execute_data->This));
58794
    } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58795
      OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58796
    }
58797
    EG(vm_stack_top) = (zval*)execute_data;
58798
    execute_data = EX(prev_execute_data);
58799
58800
    if (UNEXPECTED(EG(exception) != NULL)) {
58801
      zend_rethrow_exception(execute_data);
58802
      HANDLE_EXCEPTION_LEAVE();
58803
    }
58804
58805
    LOAD_NEXT_OPLINE();
58806
    ZEND_VM_LEAVE();
58807
  } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
58808
    EG(current_execute_data) = EX(prev_execute_data);
58809
    i_free_compiled_variables(execute_data);
58810
58811
#ifdef ZEND_PREFER_RELOAD
58812
    call_info = EX_CALL_INFO();
58813
#endif
58814
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58815
      zend_clean_and_cache_symbol_table(EX(symbol_table));
58816
    }
58817
58818
    if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
58819
      zend_free_extra_named_params(EX(extra_named_params));
58820
    }
58821
58822
    /* Free extra args before releasing the closure,
58823
     * as that may free the op_array. */
58824
    zend_vm_stack_free_extra_args_ex(call_info, execute_data);
58825
58826
    if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
58827
      OBJ_RELEASE(Z_OBJ(execute_data->This));
58828
    } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58829
      OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58830
    }
58831
58832
    old_execute_data = execute_data;
58833
    execute_data = EX(prev_execute_data);
58834
    zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
58835
58836
    if (UNEXPECTED(EG(exception) != NULL)) {
58837
      zend_rethrow_exception(execute_data);
58838
      HANDLE_EXCEPTION_LEAVE();
58839
    }
58840
58841
    LOAD_NEXT_OPLINE();
58842
    ZEND_VM_LEAVE();
58843
  } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
58844
    if (EX(func)->op_array.last_var > 0) {
58845
      zend_detach_symbol_table(execute_data);
58846
      call_info |= ZEND_CALL_NEEDS_REATTACH;
58847
    }
58848
    zend_destroy_static_vars(&EX(func)->op_array);
58849
    destroy_op_array(&EX(func)->op_array);
58850
    efree_size(EX(func), sizeof(zend_op_array));
58851
    old_execute_data = execute_data;
58852
    execute_data = EG(current_execute_data) = EX(prev_execute_data);
58853
    zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
58854
58855
    if (call_info & ZEND_CALL_NEEDS_REATTACH) {
58856
      if (EX(func)->op_array.last_var > 0) {
58857
        zend_attach_symbol_table(execute_data);
58858
      } else {
58859
        ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
58860
      }
58861
    }
58862
    if (UNEXPECTED(EG(exception) != NULL)) {
58863
      zend_rethrow_exception(execute_data);
58864
      HANDLE_EXCEPTION_LEAVE();
58865
    }
58866
58867
    LOAD_NEXT_OPLINE();
58868
    ZEND_VM_LEAVE();
58869
  } else {
58870
    if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
58871
      EG(current_execute_data) = EX(prev_execute_data);
58872
      i_free_compiled_variables(execute_data);
58873
#ifdef ZEND_PREFER_RELOAD
58874
      call_info = EX_CALL_INFO();
58875
#endif
58876
      if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
58877
        if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58878
          zend_clean_and_cache_symbol_table(EX(symbol_table));
58879
        }
58880
        zend_vm_stack_free_extra_args_ex(call_info, execute_data);
58881
        if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
58882
          zend_free_extra_named_params(EX(extra_named_params));
58883
        }
58884
      }
58885
      if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58886
        OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58887
      }
58888
      ZEND_VM_RETURN();
58889
    } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
58890
      zend_array *symbol_table = EX(symbol_table);
58891
58892
      if (EX(func)->op_array.last_var > 0) {
58893
        zend_detach_symbol_table(execute_data);
58894
        call_info |= ZEND_CALL_NEEDS_REATTACH;
58895
      }
58896
      if (call_info & ZEND_CALL_NEEDS_REATTACH) {
58897
        old_execute_data = EX(prev_execute_data);
58898
        while (old_execute_data) {
58899
          if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58900
            if (old_execute_data->symbol_table == symbol_table) {
58901
              if (old_execute_data->func->op_array.last_var > 0) {
58902
                zend_attach_symbol_table(old_execute_data);
58903
              } else {
58904
                ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
58905
              }
58906
            }
58907
            break;
58908
          }
58909
          old_execute_data = old_execute_data->prev_execute_data;
58910
        }
58911
      }
58912
      EG(current_execute_data) = EX(prev_execute_data);
58913
      ZEND_VM_RETURN();
58914
    }
58915
  }
58916
}
58917
58918
      HYBRID_CASE(ZEND_JMP_SPEC):
58919
        VM_TRACE(ZEND_JMP_SPEC)
58920
        ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58921
        VM_TRACE_OP_END(ZEND_JMP_SPEC)
58922
        HYBRID_BREAK();
58923
      HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED):
58924
        VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
58925
        ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58926
        VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
58927
        HYBRID_BREAK();
58928
      HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_USED):
58929
        VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_USED)
58930
        ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58931
        VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_USED)
58932
        HYBRID_BREAK();
58933
      HYBRID_CASE(ZEND_DO_ICALL_SPEC_OBSERVER):
58934
        VM_TRACE(ZEND_DO_ICALL_SPEC_OBSERVER)
58935
        ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58936
        VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_OBSERVER)
58937
        HYBRID_BREAK();
58938
      HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED):
58939
        VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
58940
        ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58941
        VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
58942
        HYBRID_BREAK();
58943
      HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_USED):
58944
        VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED)
58945
        ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58946
        VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_USED)
58947
        HYBRID_BREAK();
58948
      HYBRID_CASE(ZEND_DO_UCALL_SPEC_OBSERVER):
58949
        VM_TRACE(ZEND_DO_UCALL_SPEC_OBSERVER)
58950
        ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58951
        VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_OBSERVER)
58952
        HYBRID_BREAK();
58953
      HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED):
58954
        VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
58955
        ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58956
        VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
58957
        HYBRID_BREAK();
58958
      HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED):
58959
        VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
58960
        ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58961
        VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
58962
        HYBRID_BREAK();
58963
      HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER):
58964
        VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
58965
        ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58966
        VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
58967
        HYBRID_BREAK();
58968
      HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED):
58969
        VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
58970
        ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58971
        VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
58972
        HYBRID_BREAK();
58973
      HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_USED):
58974
        VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED)
58975
        ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58976
        VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_USED)
58977
        HYBRID_BREAK();
58978
      HYBRID_CASE(ZEND_DO_FCALL_SPEC_OBSERVER):
58979
        VM_TRACE(ZEND_DO_FCALL_SPEC_OBSERVER)
58980
        ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58981
        VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_OBSERVER)
58982
        HYBRID_BREAK();
58983
      HYBRID_CASE(ZEND_GENERATOR_CREATE_SPEC):
58984
        VM_TRACE(ZEND_GENERATOR_CREATE_SPEC)
58985
        ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58986
        VM_TRACE_OP_END(ZEND_GENERATOR_CREATE_SPEC)
58987
        HYBRID_BREAK();
58988
      HYBRID_CASE(ZEND_SEND_UNPACK_SPEC):
58989
        VM_TRACE(ZEND_SEND_UNPACK_SPEC)
58990
        ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58991
        VM_TRACE_OP_END(ZEND_SEND_UNPACK_SPEC)
58992
        HYBRID_BREAK();
58993
      HYBRID_CASE(ZEND_SEND_ARRAY_SPEC):
58994
        VM_TRACE(ZEND_SEND_ARRAY_SPEC)
58995
        ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58996
        VM_TRACE_OP_END(ZEND_SEND_ARRAY_SPEC)
58997
        HYBRID_BREAK();
58998
      HYBRID_CASE(ZEND_RECV_NOTYPE_SPEC):
58999
        VM_TRACE(ZEND_RECV_NOTYPE_SPEC)
59000
        ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59001
        VM_TRACE_OP_END(ZEND_RECV_NOTYPE_SPEC)
59002
        HYBRID_BREAK();
59003
      HYBRID_CASE(ZEND_ADD_ARRAY_UNPACK_SPEC):
59004
        VM_TRACE(ZEND_ADD_ARRAY_UNPACK_SPEC)
59005
        ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59006
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_UNPACK_SPEC)
59007
        HYBRID_BREAK();
59008
      HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC):
59009
        VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC)
59010
        ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59011
        VM_TRACE_OP_END(ZEND_UNSET_STATIC_PROP_SPEC)
59012
        HYBRID_BREAK();
59013
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC):
59014
        VM_TRACE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
59015
        ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59016
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
59017
        HYBRID_BREAK();
59018
      HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC):
59019
        VM_TRACE(ZEND_BEGIN_SILENCE_SPEC)
59020
        ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59021
        VM_TRACE_OP_END(ZEND_BEGIN_SILENCE_SPEC)
59022
        HYBRID_BREAK();
59023
      HYBRID_CASE(ZEND_EXT_STMT_SPEC):
59024
        VM_TRACE(ZEND_EXT_STMT_SPEC)
59025
        ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59026
        VM_TRACE_OP_END(ZEND_EXT_STMT_SPEC)
59027
        HYBRID_BREAK();
59028
      HYBRID_CASE(ZEND_EXT_FCALL_BEGIN_SPEC):
59029
        VM_TRACE(ZEND_EXT_FCALL_BEGIN_SPEC)
59030
        ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59031
        VM_TRACE_OP_END(ZEND_EXT_FCALL_BEGIN_SPEC)
59032
        HYBRID_BREAK();
59033
      HYBRID_CASE(ZEND_EXT_FCALL_END_SPEC):
59034
        VM_TRACE(ZEND_EXT_FCALL_END_SPEC)
59035
        ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59036
        VM_TRACE_OP_END(ZEND_EXT_FCALL_END_SPEC)
59037
        HYBRID_BREAK();
59038
      HYBRID_CASE(ZEND_DECLARE_ANON_CLASS_SPEC):
59039
        VM_TRACE(ZEND_DECLARE_ANON_CLASS_SPEC)
59040
        ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59041
        VM_TRACE_OP_END(ZEND_DECLARE_ANON_CLASS_SPEC)
59042
        HYBRID_BREAK();
59043
      HYBRID_CASE(ZEND_DECLARE_FUNCTION_SPEC):
59044
        VM_TRACE(ZEND_DECLARE_FUNCTION_SPEC)
59045
        ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59046
        VM_TRACE_OP_END(ZEND_DECLARE_FUNCTION_SPEC)
59047
        HYBRID_BREAK();
59048
      HYBRID_CASE(ZEND_TICKS_SPEC):
59049
        VM_TRACE(ZEND_TICKS_SPEC)
59050
        ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59051
        VM_TRACE_OP_END(ZEND_TICKS_SPEC)
59052
        HYBRID_BREAK();
59053
      HYBRID_CASE(ZEND_EXT_NOP_SPEC):
59054
        VM_TRACE(ZEND_EXT_NOP_SPEC)
59055
        ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59056
        VM_TRACE_OP_END(ZEND_EXT_NOP_SPEC)
59057
        HYBRID_BREAK();
59058
      HYBRID_CASE(ZEND_NOP_SPEC):
59059
        VM_TRACE(ZEND_NOP_SPEC)
59060
        ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59061
        VM_TRACE_OP_END(ZEND_NOP_SPEC)
59062
        HYBRID_BREAK();
59063
      HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC):
59064
        VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC)
59065
        ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59066
        VM_TRACE_OP_END(ZEND_HANDLE_EXCEPTION_SPEC)
59067
        HYBRID_BREAK();
59068
      HYBRID_CASE(ZEND_USER_OPCODE_SPEC):
59069
        VM_TRACE(ZEND_USER_OPCODE_SPEC)
59070
        ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59071
        VM_TRACE_OP_END(ZEND_USER_OPCODE_SPEC)
59072
        HYBRID_BREAK();
59073
      HYBRID_CASE(ZEND_DISCARD_EXCEPTION_SPEC):
59074
        VM_TRACE(ZEND_DISCARD_EXCEPTION_SPEC)
59075
        ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59076
        VM_TRACE_OP_END(ZEND_DISCARD_EXCEPTION_SPEC)
59077
        HYBRID_BREAK();
59078
      HYBRID_CASE(ZEND_FAST_CALL_SPEC):
59079
        VM_TRACE(ZEND_FAST_CALL_SPEC)
59080
        ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59081
        VM_TRACE_OP_END(ZEND_FAST_CALL_SPEC)
59082
        HYBRID_BREAK();
59083
      HYBRID_CASE(ZEND_FAST_RET_SPEC):
59084
        VM_TRACE(ZEND_FAST_RET_SPEC)
59085
        ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59086
        VM_TRACE_OP_END(ZEND_FAST_RET_SPEC)
59087
        HYBRID_BREAK();
59088
      HYBRID_CASE(ZEND_ASSERT_CHECK_SPEC):
59089
        VM_TRACE(ZEND_ASSERT_CHECK_SPEC)
59090
        ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59091
        VM_TRACE_OP_END(ZEND_ASSERT_CHECK_SPEC)
59092
        HYBRID_BREAK();
59093
      HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC):
59094
        VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC)
59095
        ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59096
        VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC)
59097
        HYBRID_BREAK();
59098
      HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER):
59099
        VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
59100
        ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59101
        VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
59102
        HYBRID_BREAK();
59103
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC):
59104
        VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC)
59105
        ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59106
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC)
59107
        HYBRID_BREAK();
59108
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER):
59109
        VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER)
59110
        ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59111
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER)
59112
        HYBRID_BREAK();
59113
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC):
59114
        VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC)
59115
        ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59116
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC)
59117
        HYBRID_BREAK();
59118
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER):
59119
        VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER)
59120
        ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59121
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER)
59122
        HYBRID_BREAK();
59123
      HYBRID_CASE(ZEND_JMP_FORWARD_SPEC):
59124
        VM_TRACE(ZEND_JMP_FORWARD_SPEC)
59125
        ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59126
        VM_TRACE_OP_END(ZEND_JMP_FORWARD_SPEC)
59127
        HYBRID_BREAK();
59128
      HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST):
59129
        VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
59130
        ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59131
        VM_TRACE_OP_END(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
59132
        HYBRID_BREAK();
59133
      HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST):
59134
        VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
59135
        ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59136
        VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
59137
        HYBRID_BREAK();
59138
      HYBRID_CASE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST):
59139
        VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
59140
        ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59141
        VM_TRACE_OP_END(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
59142
        HYBRID_BREAK();
59143
      HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST):
59144
        VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST)
59145
        ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59146
        VM_TRACE_OP_END(ZEND_INIT_FCALL_SPEC_CONST)
59147
        HYBRID_BREAK();
59148
      HYBRID_CASE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST):
59149
        VM_TRACE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
59150
        ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59151
        VM_TRACE_OP_END(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
59152
        HYBRID_BREAK();
59153
      HYBRID_CASE(ZEND_RECV_INIT_SPEC_CONST):
59154
        VM_TRACE(ZEND_RECV_INIT_SPEC_CONST)
59155
        ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59156
        VM_TRACE_OP_END(ZEND_RECV_INIT_SPEC_CONST)
59157
        HYBRID_BREAK();
59158
      HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR):
59159
        VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
59160
        ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59161
        VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
59162
        HYBRID_BREAK();
59163
      HYBRID_CASE(ZEND_RECV_SPEC_UNUSED):
59164
        VM_TRACE(ZEND_RECV_SPEC_UNUSED)
59165
        ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59166
        VM_TRACE_OP_END(ZEND_RECV_SPEC_UNUSED)
59167
        HYBRID_BREAK();
59168
      HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC_UNUSED):
59169
        VM_TRACE(ZEND_RECV_VARIADIC_SPEC_UNUSED)
59170
        ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59171
        VM_TRACE_OP_END(ZEND_RECV_VARIADIC_SPEC_UNUSED)
59172
        HYBRID_BREAK();
59173
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED):
59174
        VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
59175
        ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59176
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
59177
        HYBRID_BREAK();
59178
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER):
59179
        VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER)
59180
        ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59181
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER)
59182
        HYBRID_BREAK();
59183
      HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV):
59184
        VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
59185
        ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59186
        VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
59187
        HYBRID_BREAK();
59188
      HYBRID_CASE(ZEND_BW_NOT_SPEC_CONST):
59189
        VM_TRACE(ZEND_BW_NOT_SPEC_CONST)
59190
        ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59191
        VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_CONST)
59192
        HYBRID_BREAK();
59193
      HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CONST):
59194
        VM_TRACE(ZEND_BOOL_NOT_SPEC_CONST)
59195
        ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59196
        VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CONST)
59197
        HYBRID_BREAK();
59198
      HYBRID_CASE(ZEND_ECHO_SPEC_CONST):
59199
        VM_TRACE(ZEND_ECHO_SPEC_CONST)
59200
        ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59201
        VM_TRACE_OP_END(ZEND_ECHO_SPEC_CONST)
59202
        HYBRID_BREAK();
59203
      HYBRID_CASE(ZEND_JMPZ_SPEC_CONST):
59204
        VM_TRACE(ZEND_JMPZ_SPEC_CONST)
59205
        ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59206
        VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CONST)
59207
        HYBRID_BREAK();
59208
      HYBRID_CASE(ZEND_JMPNZ_SPEC_CONST):
59209
        VM_TRACE(ZEND_JMPNZ_SPEC_CONST)
59210
        ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59211
        VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CONST)
59212
        HYBRID_BREAK();
59213
      HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CONST):
59214
        VM_TRACE(ZEND_JMPZ_EX_SPEC_CONST)
59215
        ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59216
        VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CONST)
59217
        HYBRID_BREAK();
59218
      HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CONST):
59219
        VM_TRACE(ZEND_JMPNZ_EX_SPEC_CONST)
59220
        ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59221
        VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CONST)
59222
        HYBRID_BREAK();
59223
      HYBRID_CASE(ZEND_RETURN_SPEC_CONST):
59224
        VM_TRACE(ZEND_RETURN_SPEC_CONST)
59225
{
59226
  USE_OPLINE
59227
  zval *retval_ptr;
59228
  zval *return_value;
59229
59230
  retval_ptr = RT_CONSTANT(opline, opline->op1);
59231
  return_value = EX(return_value);
59232
59233
  if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59234
    SAVE_OPLINE();
59235
    retval_ptr = ZVAL_UNDEFINED_OP1();
59236
    if (return_value) {
59237
      ZVAL_NULL(return_value);
59238
    }
59239
  } else if (!return_value) {
59240
    if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
59241
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59242
        SAVE_OPLINE();
59243
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
59244
      }
59245
    }
59246
  } else {
59247
    if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
59248
      ZVAL_COPY_VALUE(return_value, retval_ptr);
59249
      if (IS_CONST == IS_CONST) {
59250
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59251
          Z_ADDREF_P(return_value);
59252
        }
59253
      }
59254
    } else if (IS_CONST == IS_CV) {
59255
      do {
59256
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59257
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59258
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59259
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59260
              ZVAL_COPY_VALUE(return_value, retval_ptr);
59261
              if (GC_MAY_LEAK(ref)) {
59262
                SAVE_OPLINE();
59263
                gc_possible_root(ref);
59264
              }
59265
              ZVAL_NULL(retval_ptr);
59266
              break;
59267
            } else {
59268
              Z_ADDREF_P(retval_ptr);
59269
            }
59270
          } else {
59271
            retval_ptr = Z_REFVAL_P(retval_ptr);
59272
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59273
              Z_ADDREF_P(retval_ptr);
59274
            }
59275
          }
59276
        }
59277
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59278
      } while (0);
59279
    } else /* if (IS_CONST == IS_VAR) */ {
59280
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59281
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59282
59283
        retval_ptr = Z_REFVAL_P(retval_ptr);
59284
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59285
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59286
          efree_size(ref, sizeof(zend_reference));
59287
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59288
          Z_ADDREF_P(retval_ptr);
59289
        }
59290
      } else {
59291
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59292
      }
59293
    }
59294
  }
59295
59296
59297
59298
  goto zend_leave_helper_SPEC_LABEL;
59299
}
59300
59301
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_CONST)
59302
      HYBRID_CASE(ZEND_RETURN_SPEC_OBSERVER):
59303
        VM_TRACE(ZEND_RETURN_SPEC_OBSERVER)
59304
{
59305
  USE_OPLINE
59306
  zval *retval_ptr;
59307
  zval *return_value;
59308
  zval observer_retval;
59309
59310
  retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
59311
  return_value = EX(return_value);
59312
  if (!return_value) { return_value = &observer_retval; };
59313
  if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59314
    SAVE_OPLINE();
59315
    retval_ptr = ZVAL_UNDEFINED_OP1();
59316
    if (return_value) {
59317
      ZVAL_NULL(return_value);
59318
    }
59319
  } else if (!return_value) {
59320
    if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
59321
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59322
        SAVE_OPLINE();
59323
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
59324
      }
59325
    }
59326
  } else {
59327
    if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
59328
      ZVAL_COPY_VALUE(return_value, retval_ptr);
59329
      if (opline->op1_type == IS_CONST) {
59330
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59331
          Z_ADDREF_P(return_value);
59332
        }
59333
      }
59334
    } else if (opline->op1_type == IS_CV) {
59335
      do {
59336
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59337
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59338
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59339
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59340
              ZVAL_COPY_VALUE(return_value, retval_ptr);
59341
              if (GC_MAY_LEAK(ref)) {
59342
                SAVE_OPLINE();
59343
                gc_possible_root(ref);
59344
              }
59345
              ZVAL_NULL(retval_ptr);
59346
              break;
59347
            } else {
59348
              Z_ADDREF_P(retval_ptr);
59349
            }
59350
          } else {
59351
            retval_ptr = Z_REFVAL_P(retval_ptr);
59352
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59353
              Z_ADDREF_P(retval_ptr);
59354
            }
59355
          }
59356
        }
59357
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59358
      } while (0);
59359
    } else /* if (opline->op1_type == IS_VAR) */ {
59360
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59361
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59362
59363
        retval_ptr = Z_REFVAL_P(retval_ptr);
59364
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59365
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59366
          efree_size(ref, sizeof(zend_reference));
59367
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59368
          Z_ADDREF_P(retval_ptr);
59369
        }
59370
      } else {
59371
        ZVAL_COPY_VALUE(return_value, retval_ptr);
59372
      }
59373
    }
59374
  }
59375
  SAVE_OPLINE();
59376
  zend_observer_fcall_end(execute_data, return_value);
59377
  if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
59378
  goto zend_leave_helper_SPEC_LABEL;
59379
}
59380
59381
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_OBSERVER)
59382
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CONST):
59383
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST)
59384
        ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59385
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CONST)
59386
        HYBRID_BREAK();
59387
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_OBSERVER):
59388
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
59389
        ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59390
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
59391
        HYBRID_BREAK();
59392
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST):
59393
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST)
59394
        ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59395
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CONST)
59396
        HYBRID_BREAK();
59397
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER):
59398
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
59399
        ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59400
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
59401
        HYBRID_BREAK();
59402
      HYBRID_CASE(ZEND_THROW_SPEC_CONST):
59403
        VM_TRACE(ZEND_THROW_SPEC_CONST)
59404
        ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59405
        VM_TRACE_OP_END(ZEND_THROW_SPEC_CONST)
59406
        HYBRID_BREAK();
59407
      HYBRID_CASE(ZEND_CATCH_SPEC_CONST):
59408
        VM_TRACE(ZEND_CATCH_SPEC_CONST)
59409
        ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59410
        VM_TRACE_OP_END(ZEND_CATCH_SPEC_CONST)
59411
        HYBRID_BREAK();
59412
      HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST):
59413
        VM_TRACE(ZEND_SEND_USER_SPEC_CONST)
59414
        ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59415
        VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST)
59416
        HYBRID_BREAK();
59417
      HYBRID_CASE(ZEND_BOOL_SPEC_CONST):
59418
        VM_TRACE(ZEND_BOOL_SPEC_CONST)
59419
        ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59420
        VM_TRACE_OP_END(ZEND_BOOL_SPEC_CONST)
59421
        HYBRID_BREAK();
59422
      HYBRID_CASE(ZEND_CLONE_SPEC_CONST):
59423
        VM_TRACE(ZEND_CLONE_SPEC_CONST)
59424
        ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59425
        VM_TRACE_OP_END(ZEND_CLONE_SPEC_CONST)
59426
        HYBRID_BREAK();
59427
      HYBRID_CASE(ZEND_CAST_SPEC_CONST):
59428
        VM_TRACE(ZEND_CAST_SPEC_CONST)
59429
        ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59430
        VM_TRACE_OP_END(ZEND_CAST_SPEC_CONST)
59431
        HYBRID_BREAK();
59432
      HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST):
59433
        VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
59434
        ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59435
        VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
59436
        HYBRID_BREAK();
59437
      HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER):
59438
        VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
59439
        ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59440
        VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
59441
        HYBRID_BREAK();
59442
      HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CONST):
59443
        VM_TRACE(ZEND_FE_RESET_R_SPEC_CONST)
59444
        ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59445
        VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CONST)
59446
        HYBRID_BREAK();
59447
      HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CONST):
59448
        VM_TRACE(ZEND_FE_RESET_RW_SPEC_CONST)
59449
        ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59450
        VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CONST)
59451
        HYBRID_BREAK();
59452
      HYBRID_CASE(ZEND_JMP_SET_SPEC_CONST):
59453
        VM_TRACE(ZEND_JMP_SET_SPEC_CONST)
59454
        ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59455
        VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CONST)
59456
        HYBRID_BREAK();
59457
      HYBRID_CASE(ZEND_COALESCE_SPEC_CONST):
59458
        VM_TRACE(ZEND_COALESCE_SPEC_CONST)
59459
        ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59460
        VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CONST)
59461
        HYBRID_BREAK();
59462
      HYBRID_CASE(ZEND_JMP_NULL_SPEC_CONST):
59463
        VM_TRACE(ZEND_JMP_NULL_SPEC_CONST)
59464
        ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59465
        VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CONST)
59466
        HYBRID_BREAK();
59467
      HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CONST):
59468
        VM_TRACE(ZEND_QM_ASSIGN_SPEC_CONST)
59469
        ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59470
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CONST)
59471
        HYBRID_BREAK();
59472
      HYBRID_CASE(ZEND_DECLARE_CLASS_SPEC_CONST):
59473
        VM_TRACE(ZEND_DECLARE_CLASS_SPEC_CONST)
59474
        ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59475
        VM_TRACE_OP_END(ZEND_DECLARE_CLASS_SPEC_CONST)
59476
        HYBRID_BREAK();
59477
      HYBRID_CASE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST):
59478
        VM_TRACE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
59479
        ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59480
        VM_TRACE_OP_END(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
59481
        HYBRID_BREAK();
59482
      HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CONST):
59483
        VM_TRACE(ZEND_YIELD_FROM_SPEC_CONST)
59484
        ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59485
        VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CONST)
59486
        HYBRID_BREAK();
59487
      HYBRID_CASE(ZEND_STRLEN_SPEC_CONST):
59488
        VM_TRACE(ZEND_STRLEN_SPEC_CONST)
59489
        ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59490
        VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CONST)
59491
        HYBRID_BREAK();
59492
      HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CONST):
59493
        VM_TRACE(ZEND_TYPE_CHECK_SPEC_CONST)
59494
        ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59495
        VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST)
59496
        HYBRID_BREAK();
59497
      HYBRID_CASE(ZEND_DEFINED_SPEC_CONST):
59498
        VM_TRACE(ZEND_DEFINED_SPEC_CONST)
59499
        ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59500
        VM_TRACE_OP_END(ZEND_DEFINED_SPEC_CONST)
59501
        HYBRID_BREAK();
59502
      HYBRID_CASE(ZEND_JMP_FRAMELESS_SPEC_CONST):
59503
        VM_TRACE(ZEND_JMP_FRAMELESS_SPEC_CONST)
59504
        ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59505
        VM_TRACE_OP_END(ZEND_JMP_FRAMELESS_SPEC_CONST)
59506
        HYBRID_BREAK();
59507
      HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_CONST):
59508
        VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
59509
        ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59510
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
59511
        HYBRID_BREAK();
59512
      HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST):
59513
        VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
59514
        ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59515
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
59516
        HYBRID_BREAK();
59517
      HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST):
59518
        VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
59519
        ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59520
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
59521
        HYBRID_BREAK();
59522
      HYBRID_CASE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST):
59523
        VM_TRACE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
59524
        ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59525
        VM_TRACE_OP_END(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
59526
        HYBRID_BREAK();
59527
      HYBRID_CASE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST):
59528
        VM_TRACE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
59529
        ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59530
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
59531
        HYBRID_BREAK();
59532
      HYBRID_CASE(ZEND_ADD_SPEC_CONST_CONST):
59533
        VM_TRACE(ZEND_ADD_SPEC_CONST_CONST)
59534
        ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59535
        VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_CONST)
59536
        HYBRID_BREAK();
59537
      HYBRID_CASE(ZEND_SUB_SPEC_CONST_CONST):
59538
        VM_TRACE(ZEND_SUB_SPEC_CONST_CONST)
59539
        ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59540
        VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_CONST)
59541
        HYBRID_BREAK();
59542
      HYBRID_CASE(ZEND_MUL_SPEC_CONST_CONST):
59543
        VM_TRACE(ZEND_MUL_SPEC_CONST_CONST)
59544
        ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59545
        VM_TRACE_OP_END(ZEND_MUL_SPEC_CONST_CONST)
59546
        HYBRID_BREAK();
59547
      HYBRID_CASE(ZEND_DIV_SPEC_CONST_CONST):
59548
        VM_TRACE(ZEND_DIV_SPEC_CONST_CONST)
59549
        ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59550
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CONST)
59551
        HYBRID_BREAK();
59552
      HYBRID_CASE(ZEND_MOD_SPEC_CONST_CONST):
59553
        VM_TRACE(ZEND_MOD_SPEC_CONST_CONST)
59554
        ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59555
        VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_CONST)
59556
        HYBRID_BREAK();
59557
      HYBRID_CASE(ZEND_SL_SPEC_CONST_CONST):
59558
        VM_TRACE(ZEND_SL_SPEC_CONST_CONST)
59559
        ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59560
        VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_CONST)
59561
        HYBRID_BREAK();
59562
      HYBRID_CASE(ZEND_SR_SPEC_CONST_CONST):
59563
        VM_TRACE(ZEND_SR_SPEC_CONST_CONST)
59564
        ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59565
        VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_CONST)
59566
        HYBRID_BREAK();
59567
      HYBRID_CASE(ZEND_POW_SPEC_CONST_CONST):
59568
        VM_TRACE(ZEND_POW_SPEC_CONST_CONST)
59569
        ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59570
        VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CONST)
59571
        HYBRID_BREAK();
59572
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST):
59573
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
59574
        ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59575
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
59576
        HYBRID_BREAK();
59577
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST):
59578
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
59579
        ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59580
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
59581
        HYBRID_BREAK();
59582
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CONST_CONST):
59583
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CONST_CONST)
59584
        ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59585
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CONST_CONST)
59586
        HYBRID_BREAK();
59587
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST):
59588
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
59589
        ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59590
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
59591
        HYBRID_BREAK();
59592
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_CONST):
59593
        VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_CONST)
59594
        ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59595
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_CONST)
59596
        HYBRID_BREAK();
59597
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST):
59598
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
59599
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59600
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
59601
        HYBRID_BREAK();
59602
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CONST):
59603
        VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CONST)
59604
        ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59605
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CONST)
59606
        HYBRID_BREAK();
59607
      HYBRID_CASE(ZEND_BW_OR_SPEC_CONST_CONST):
59608
        VM_TRACE(ZEND_BW_OR_SPEC_CONST_CONST)
59609
        ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59610
        VM_TRACE_OP_END(ZEND_BW_OR_SPEC_CONST_CONST)
59611
        HYBRID_BREAK();
59612
      HYBRID_CASE(ZEND_BW_AND_SPEC_CONST_CONST):
59613
        VM_TRACE(ZEND_BW_AND_SPEC_CONST_CONST)
59614
        ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59615
        VM_TRACE_OP_END(ZEND_BW_AND_SPEC_CONST_CONST)
59616
        HYBRID_BREAK();
59617
      HYBRID_CASE(ZEND_BW_XOR_SPEC_CONST_CONST):
59618
        VM_TRACE(ZEND_BW_XOR_SPEC_CONST_CONST)
59619
        ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59620
        VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_CONST_CONST)
59621
        HYBRID_BREAK();
59622
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CONST_CONST):
59623
        VM_TRACE(ZEND_BOOL_XOR_SPEC_CONST_CONST)
59624
        ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59625
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CONST_CONST)
59626
        HYBRID_BREAK();
59627
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST):
59628
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
59629
        ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59630
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
59631
        HYBRID_BREAK();
59632
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST):
59633
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
59634
        ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59635
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
59636
        HYBRID_BREAK();
59637
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST):
59638
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
59639
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59640
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
59641
        HYBRID_BREAK();
59642
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST):
59643
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
59644
        ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59645
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
59646
        HYBRID_BREAK();
59647
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST):
59648
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
59649
        ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59650
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
59651
        HYBRID_BREAK();
59652
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST):
59653
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
59654
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59655
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
59656
        HYBRID_BREAK();
59657
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST):
59658
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
59659
        ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59660
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
59661
        HYBRID_BREAK();
59662
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CONST):
59663
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
59664
        ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59665
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
59666
        HYBRID_BREAK();
59667
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST):
59668
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
59669
        ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59670
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
59671
        HYBRID_BREAK();
59672
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST):
59673
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
59674
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59675
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
59676
        HYBRID_BREAK();
59677
      HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST):
59678
        VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
59679
        ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59680
        VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
59681
        HYBRID_BREAK();
59682
      HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST):
59683
        VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST)
59684
        ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59685
        VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_CONST)
59686
        HYBRID_BREAK();
59687
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST):
59688
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
59689
        ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59690
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
59691
        HYBRID_BREAK();
59692
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST):
59693
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
59694
        ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59695
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
59696
        HYBRID_BREAK();
59697
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST):
59698
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
59699
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59700
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
59701
        HYBRID_BREAK();
59702
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CONST):
59703
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
59704
        ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59705
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
59706
        HYBRID_BREAK();
59707
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST):
59708
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
59709
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59710
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
59711
        HYBRID_BREAK();
59712
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST):
59713
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
59714
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59715
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
59716
        HYBRID_BREAK();
59717
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST):
59718
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
59719
        ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59720
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
59721
        HYBRID_BREAK();
59722
      HYBRID_CASE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST):
59723
        VM_TRACE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
59724
        ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59725
        VM_TRACE_OP_END(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
59726
        HYBRID_BREAK();
59727
      HYBRID_CASE(ZEND_DECLARE_CONST_SPEC_CONST_CONST):
59728
        VM_TRACE(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
59729
        ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59730
        VM_TRACE_OP_END(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
59731
        HYBRID_BREAK();
59732
      HYBRID_CASE(ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST):
59733
        VM_TRACE(ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST)
59734
        ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59735
        VM_TRACE_OP_END(ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST)
59736
        HYBRID_BREAK();
59737
      HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CONST):
59738
        VM_TRACE(ZEND_YIELD_SPEC_CONST_CONST)
59739
        ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59740
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CONST)
59741
        HYBRID_BREAK();
59742
      HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_CONST_CONST):
59743
        VM_TRACE(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
59744
        ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59745
        VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
59746
        HYBRID_BREAK();
59747
      HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_CONST_CONST):
59748
        VM_TRACE(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
59749
        ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59750
        VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
59751
        HYBRID_BREAK();
59752
      HYBRID_CASE(ZEND_MATCH_SPEC_CONST_CONST):
59753
        VM_TRACE(ZEND_MATCH_SPEC_CONST_CONST)
59754
        ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59755
        VM_TRACE_OP_END(ZEND_MATCH_SPEC_CONST_CONST)
59756
        HYBRID_BREAK();
59757
      HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CONST_CONST):
59758
        VM_TRACE(ZEND_IN_ARRAY_SPEC_CONST_CONST)
59759
        ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59760
        VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CONST_CONST)
59761
        HYBRID_BREAK();
59762
      HYBRID_CASE(ZEND_ADD_SPEC_CONST_TMPVARCV):
59763
        VM_TRACE(ZEND_ADD_SPEC_CONST_TMPVARCV)
59764
        ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59765
        VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_TMPVARCV)
59766
        HYBRID_BREAK();
59767
      HYBRID_CASE(ZEND_SUB_SPEC_CONST_TMPVARCV):
59768
        VM_TRACE(ZEND_SUB_SPEC_CONST_TMPVARCV)
59769
        ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59770
        VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_TMPVARCV)
59771
        HYBRID_BREAK();
59772
      HYBRID_CASE(ZEND_MOD_SPEC_CONST_TMPVARCV):
59773
        VM_TRACE(ZEND_MOD_SPEC_CONST_TMPVARCV)
59774
        ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59775
        VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_TMPVARCV)
59776
        HYBRID_BREAK();
59777
      HYBRID_CASE(ZEND_SL_SPEC_CONST_TMPVARCV):
59778
        VM_TRACE(ZEND_SL_SPEC_CONST_TMPVARCV)
59779
        ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59780
        VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_TMPVARCV)
59781
        HYBRID_BREAK();
59782
      HYBRID_CASE(ZEND_SR_SPEC_CONST_TMPVARCV):
59783
        VM_TRACE(ZEND_SR_SPEC_CONST_TMPVARCV)
59784
        ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59785
        VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_TMPVARCV)
59786
        HYBRID_BREAK();
59787
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV):
59788
        VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
59789
        ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59790
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
59791
        HYBRID_BREAK();
59792
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ):
59793
        VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
59794
        ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59795
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
59796
        HYBRID_BREAK();
59797
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ):
59798
        VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
59799
        ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59800
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
59801
        HYBRID_BREAK();
59802
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV):
59803
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
59804
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59805
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
59806
        HYBRID_BREAK();
59807
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ):
59808
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
59809
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59810
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
59811
        HYBRID_BREAK();
59812
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ):
59813
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
59814
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59815
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
59816
        HYBRID_BREAK();
59817
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV):
59818
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
59819
        ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59820
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
59821
        HYBRID_BREAK();
59822
      HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV):
59823
        VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
59824
        ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59825
        VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
59826
        HYBRID_BREAK();
59827
      HYBRID_CASE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV):
59828
        VM_TRACE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
59829
        ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59830
        VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
59831
        HYBRID_BREAK();
59832
      HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV):
59833
        VM_TRACE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
59834
        ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59835
        VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
59836
        HYBRID_BREAK();
59837
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV):
59838
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
59839
        ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59840
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
59841
        HYBRID_BREAK();
59842
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ):
59843
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59844
        ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59845
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59846
        HYBRID_BREAK();
59847
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
59848
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59849
        ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59850
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59851
        HYBRID_BREAK();
59852
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV):
59853
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
59854
        ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59855
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
59856
        HYBRID_BREAK();
59857
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
59858
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59859
        ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59860
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59861
        HYBRID_BREAK();
59862
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
59863
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59864
        ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59865
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59866
        HYBRID_BREAK();
59867
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV):
59868
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
59869
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59870
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
59871
        HYBRID_BREAK();
59872
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ):
59873
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59874
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59875
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59876
        HYBRID_BREAK();
59877
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
59878
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59879
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59880
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59881
        HYBRID_BREAK();
59882
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV):
59883
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
59884
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59885
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
59886
        HYBRID_BREAK();
59887
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
59888
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59889
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59890
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59891
        HYBRID_BREAK();
59892
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
59893
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59894
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59895
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59896
        HYBRID_BREAK();
59897
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV):
59898
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
59899
        ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59900
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
59901
        HYBRID_BREAK();
59902
      HYBRID_CASE(ZEND_DIV_SPEC_CONST_TMPVAR):
59903
        VM_TRACE(ZEND_DIV_SPEC_CONST_TMPVAR)
59904
        ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59905
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_TMPVAR)
59906
        HYBRID_BREAK();
59907
      HYBRID_CASE(ZEND_POW_SPEC_CONST_TMPVAR):
59908
        VM_TRACE(ZEND_POW_SPEC_CONST_TMPVAR)
59909
        ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59910
        VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_TMPVAR)
59911
        HYBRID_BREAK();
59912
      HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_TMPVAR):
59913
        VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMPVAR)
59914
        ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59915
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_TMPVAR)
59916
        HYBRID_BREAK();
59917
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR):
59918
        VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
59919
        ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59920
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
59921
        HYBRID_BREAK();
59922
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR):
59923
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
59924
        ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59925
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
59926
        HYBRID_BREAK();
59927
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR):
59928
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
59929
        ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59930
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
59931
        HYBRID_BREAK();
59932
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR):
59933
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
59934
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59935
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
59936
        HYBRID_BREAK();
59937
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR):
59938
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
59939
        ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59940
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
59941
        HYBRID_BREAK();
59942
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR):
59943
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
59944
        ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59945
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
59946
        HYBRID_BREAK();
59947
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR):
59948
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
59949
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59950
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
59951
        HYBRID_BREAK();
59952
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR):
59953
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
59954
        ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59955
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
59956
        HYBRID_BREAK();
59957
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR):
59958
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
59959
        ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59960
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
59961
        HYBRID_BREAK();
59962
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR):
59963
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
59964
        ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59965
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
59966
        HYBRID_BREAK();
59967
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR):
59968
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
59969
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59970
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
59971
        HYBRID_BREAK();
59972
      HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR):
59973
        VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
59974
        ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59975
        VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
59976
        HYBRID_BREAK();
59977
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR):
59978
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
59979
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59980
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
59981
        HYBRID_BREAK();
59982
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR):
59983
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
59984
        ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59985
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
59986
        HYBRID_BREAK();
59987
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR):
59988
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
59989
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59990
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
59991
        HYBRID_BREAK();
59992
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR):
59993
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
59994
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59995
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
59996
        HYBRID_BREAK();
59997
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR):
59998
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
59999
        ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60000
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
60001
        HYBRID_BREAK();
60002
      HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMPVAR):
60003
        VM_TRACE(ZEND_YIELD_SPEC_CONST_TMPVAR)
60004
        ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60005
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMPVAR)
60006
        HYBRID_BREAK();
60007
      HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED):
60008
        VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED)
60009
        ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60010
        VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CONST_UNUSED)
60011
        HYBRID_BREAK();
60012
      HYBRID_CASE(ZEND_FETCH_W_SPEC_CONST_UNUSED):
60013
        VM_TRACE(ZEND_FETCH_W_SPEC_CONST_UNUSED)
60014
        ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60015
        VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CONST_UNUSED)
60016
        HYBRID_BREAK();
60017
      HYBRID_CASE(ZEND_FETCH_RW_SPEC_CONST_UNUSED):
60018
        VM_TRACE(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
60019
        ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60020
        VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
60021
        HYBRID_BREAK();
60022
      HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED):
60023
        VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
60024
        ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60025
        VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
60026
        HYBRID_BREAK();
60027
      HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED):
60028
        VM_TRACE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
60029
        ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60030
        VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
60031
        HYBRID_BREAK();
60032
      HYBRID_CASE(ZEND_FETCH_IS_SPEC_CONST_UNUSED):
60033
        VM_TRACE(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
60034
        ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60035
        VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
60036
        HYBRID_BREAK();
60037
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED):
60038
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
60039
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60040
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
60041
        HYBRID_BREAK();
60042
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED):
60043
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
60044
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60045
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
60046
        HYBRID_BREAK();
60047
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED):
60048
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
60049
        ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60050
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
60051
        HYBRID_BREAK();
60052
      HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_UNUSED):
60053
        VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
60054
        ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60055
        VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
60056
        HYBRID_BREAK();
60057
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED):
60058
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
60059
        ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60060
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
60061
        HYBRID_BREAK();
60062
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK):
60063
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
60064
        ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60065
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
60066
        HYBRID_BREAK();
60067
      HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED):
60068
        VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED)
60069
        ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60070
        VM_TRACE_OP_END(ZEND_NEW_SPEC_CONST_UNUSED)
60071
        HYBRID_BREAK();
60072
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED):
60073
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
60074
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60075
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
60076
        HYBRID_BREAK();
60077
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED):
60078
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
60079
        ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60080
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
60081
        HYBRID_BREAK();
60082
      HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED):
60083
        VM_TRACE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
60084
        ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60085
        VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
60086
        HYBRID_BREAK();
60087
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED):
60088
        VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
60089
        ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60090
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
60091
        HYBRID_BREAK();
60092
      HYBRID_CASE(ZEND_YIELD_SPEC_CONST_UNUSED):
60093
        VM_TRACE(ZEND_YIELD_SPEC_CONST_UNUSED)
60094
        ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60095
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_UNUSED)
60096
        HYBRID_BREAK();
60097
      HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED):
60098
        VM_TRACE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
60099
        ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60100
        VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
60101
        HYBRID_BREAK();
60102
      HYBRID_CASE(ZEND_COUNT_SPEC_CONST_UNUSED):
60103
        VM_TRACE(ZEND_COUNT_SPEC_CONST_UNUSED)
60104
        ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60105
        VM_TRACE_OP_END(ZEND_COUNT_SPEC_CONST_UNUSED)
60106
        HYBRID_BREAK();
60107
      HYBRID_CASE(ZEND_GET_CLASS_SPEC_CONST_UNUSED):
60108
        VM_TRACE(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
60109
        ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60110
        VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
60111
        HYBRID_BREAK();
60112
      HYBRID_CASE(ZEND_GET_TYPE_SPEC_CONST_UNUSED):
60113
        VM_TRACE(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
60114
        ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60115
        VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
60116
        HYBRID_BREAK();
60117
      HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED):
60118
        VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
60119
        ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60120
        VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
60121
        HYBRID_BREAK();
60122
      HYBRID_CASE(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED):
60123
        VM_TRACE(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
60124
        ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60125
        VM_TRACE_OP_END(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
60126
        HYBRID_BREAK();
60127
      HYBRID_CASE(ZEND_DIV_SPEC_CONST_CV):
60128
        VM_TRACE(ZEND_DIV_SPEC_CONST_CV)
60129
        ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60130
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CV)
60131
        HYBRID_BREAK();
60132
      HYBRID_CASE(ZEND_POW_SPEC_CONST_CV):
60133
        VM_TRACE(ZEND_POW_SPEC_CONST_CV)
60134
        ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60135
        VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CV)
60136
        HYBRID_BREAK();
60137
      HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_CV):
60138
        VM_TRACE(ZEND_CONCAT_SPEC_CONST_CV)
60139
        ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60140
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_CV)
60141
        HYBRID_BREAK();
60142
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CV):
60143
        VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CV)
60144
        ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60145
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CV)
60146
        HYBRID_BREAK();
60147
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CV):
60148
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
60149
        ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60150
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
60151
        HYBRID_BREAK();
60152
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV):
60153
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
60154
        ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60155
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
60156
        HYBRID_BREAK();
60157
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV):
60158
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
60159
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60160
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
60161
        HYBRID_BREAK();
60162
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV):
60163
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
60164
        ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60165
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
60166
        HYBRID_BREAK();
60167
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV):
60168
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
60169
        ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60170
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
60171
        HYBRID_BREAK();
60172
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV):
60173
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
60174
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60175
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
60176
        HYBRID_BREAK();
60177
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CV):
60178
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
60179
        ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60180
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
60181
        HYBRID_BREAK();
60182
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CV):
60183
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CV)
60184
        ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60185
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CV)
60186
        HYBRID_BREAK();
60187
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV):
60188
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
60189
        ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60190
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
60191
        HYBRID_BREAK();
60192
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV):
60193
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
60194
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60195
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
60196
        HYBRID_BREAK();
60197
      HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV):
60198
        VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
60199
        ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60200
        VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
60201
        HYBRID_BREAK();
60202
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV):
60203
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
60204
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60205
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
60206
        HYBRID_BREAK();
60207
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CV):
60208
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CV)
60209
        ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60210
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CV)
60211
        HYBRID_BREAK();
60212
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV):
60213
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
60214
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60215
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
60216
        HYBRID_BREAK();
60217
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV):
60218
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
60219
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60220
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
60221
        HYBRID_BREAK();
60222
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV):
60223
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
60224
        ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60225
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
60226
        HYBRID_BREAK();
60227
      HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CV):
60228
        VM_TRACE(ZEND_YIELD_SPEC_CONST_CV)
60229
        ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60230
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CV)
60231
        HYBRID_BREAK();
60232
      HYBRID_CASE(ZEND_BW_NOT_SPEC_TMPVARCV):
60233
        VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV)
60234
        ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60235
        VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_TMPVARCV)
60236
        HYBRID_BREAK();
60237
      HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV):
60238
        VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
60239
        ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60240
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
60241
        HYBRID_BREAK();
60242
      HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV):
60243
        VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
60244
        ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60245
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
60246
        HYBRID_BREAK();
60247
      HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV):
60248
        VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
60249
        ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60250
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
60251
        HYBRID_BREAK();
60252
      HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_CONST):
60253
        VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_CONST)
60254
        ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60255
        VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_CONST)
60256
        HYBRID_BREAK();
60257
      HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_CONST):
60258
        VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_CONST)
60259
        ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60260
        VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_CONST)
60261
        HYBRID_BREAK();
60262
      HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_CONST):
60263
        VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_CONST)
60264
        ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60265
        VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_CONST)
60266
        HYBRID_BREAK();
60267
      HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_CONST):
60268
        VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_CONST)
60269
        ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60270
        VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_CONST)
60271
        HYBRID_BREAK();
60272
      HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_CONST):
60273
        VM_TRACE(ZEND_SL_SPEC_TMPVARCV_CONST)
60274
        ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60275
        VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_CONST)
60276
        HYBRID_BREAK();
60277
      HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_CONST):
60278
        VM_TRACE(ZEND_SR_SPEC_TMPVARCV_CONST)
60279
        ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60280
        VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_CONST)
60281
        HYBRID_BREAK();
60282
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST):
60283
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
60284
        ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60285
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
60286
        HYBRID_BREAK();
60287
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ):
60288
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
60289
        ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60290
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
60291
        HYBRID_BREAK();
60292
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ):
60293
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
60294
        ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60295
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
60296
        HYBRID_BREAK();
60297
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST):
60298
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
60299
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60300
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
60301
        HYBRID_BREAK();
60302
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ):
60303
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
60304
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60305
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
60306
        HYBRID_BREAK();
60307
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ):
60308
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
60309
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60310
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
60311
        HYBRID_BREAK();
60312
      HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_CONST):
60313
        VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
60314
        ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60315
        VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
60316
        HYBRID_BREAK();
60317
      HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_CONST):
60318
        VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
60319
        ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60320
        VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
60321
        HYBRID_BREAK();
60322
      HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST):
60323
        VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
60324
        ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60325
        VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
60326
        HYBRID_BREAK();
60327
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST):
60328
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
60329
        ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60330
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
60331
        HYBRID_BREAK();
60332
      HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST):
60333
        VM_TRACE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
60334
        ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60335
        VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
60336
        HYBRID_BREAK();
60337
      HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST):
60338
        VM_TRACE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
60339
        ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60340
        VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
60341
        HYBRID_BREAK();
60342
      HYBRID_CASE(ZEND_MATCH_SPEC_TMPVARCV_CONST):
60343
        VM_TRACE(ZEND_MATCH_SPEC_TMPVARCV_CONST)
60344
        ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60345
        VM_TRACE_OP_END(ZEND_MATCH_SPEC_TMPVARCV_CONST)
60346
        HYBRID_BREAK();
60347
      HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60348
        VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60349
        ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60350
        VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60351
        HYBRID_BREAK();
60352
      HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST):
60353
        VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
60354
        ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60355
        VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
60356
        HYBRID_BREAK();
60357
      HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST):
60358
        VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
60359
        ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60360
        VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
60361
        HYBRID_BREAK();
60362
      HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60363
        VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60364
        ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60365
        VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60366
        HYBRID_BREAK();
60367
      HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST):
60368
        VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
60369
        ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60370
        VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
60371
        HYBRID_BREAK();
60372
      HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST):
60373
        VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
60374
        ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60375
        VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
60376
        HYBRID_BREAK();
60377
      HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60378
        VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60379
        ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60380
        VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60381
        HYBRID_BREAK();
60382
      HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST):
60383
        VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
60384
        ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60385
        VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
60386
        HYBRID_BREAK();
60387
      HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST):
60388
        VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
60389
        ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60390
        VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
60391
        HYBRID_BREAK();
60392
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60393
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60394
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60395
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60396
        HYBRID_BREAK();
60397
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60398
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60399
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60400
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60401
        HYBRID_BREAK();
60402
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60403
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60404
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60405
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60406
        HYBRID_BREAK();
60407
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60408
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60409
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60410
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60411
        HYBRID_BREAK();
60412
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60413
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60414
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60415
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60416
        HYBRID_BREAK();
60417
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60418
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60419
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60420
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60421
        HYBRID_BREAK();
60422
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60423
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60424
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60425
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60426
        HYBRID_BREAK();
60427
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60428
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60429
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60430
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60431
        HYBRID_BREAK();
60432
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60433
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60434
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60435
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60436
        HYBRID_BREAK();
60437
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60438
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60439
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60440
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60441
        HYBRID_BREAK();
60442
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60443
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60444
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60445
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60446
        HYBRID_BREAK();
60447
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60448
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60449
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60450
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60451
        HYBRID_BREAK();
60452
      HYBRID_CASE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST):
60453
        VM_TRACE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST)
60454
        ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60455
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST)
60456
        HYBRID_BREAK();
60457
      HYBRID_CASE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ):
60458
        VM_TRACE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ)
60459
        ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60460
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ)
60461
        HYBRID_BREAK();
60462
      HYBRID_CASE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ):
60463
        VM_TRACE(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ)
60464
        ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60465
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ)
60466
        HYBRID_BREAK();
60467
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST):
60468
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST)
60469
        ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60470
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST)
60471
        HYBRID_BREAK();
60472
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ):
60473
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ)
60474
        ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60475
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ)
60476
        HYBRID_BREAK();
60477
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ):
60478
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ)
60479
        ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60480
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ)
60481
        HYBRID_BREAK();
60482
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST):
60483
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
60484
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60485
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
60486
        HYBRID_BREAK();
60487
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60488
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60489
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60490
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60491
        HYBRID_BREAK();
60492
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60493
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60494
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60495
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60496
        HYBRID_BREAK();
60497
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST):
60498
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
60499
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60500
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
60501
        HYBRID_BREAK();
60502
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60503
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60504
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60505
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60506
        HYBRID_BREAK();
60507
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60508
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60509
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60510
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60511
        HYBRID_BREAK();
60512
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60513
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60514
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60515
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60516
        HYBRID_BREAK();
60517
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60518
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60519
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60520
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60521
        HYBRID_BREAK();
60522
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60523
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60524
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60525
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60526
        HYBRID_BREAK();
60527
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60528
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60529
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60530
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60531
        HYBRID_BREAK();
60532
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60533
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60534
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60535
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60536
        HYBRID_BREAK();
60537
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60538
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60539
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60540
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60541
        HYBRID_BREAK();
60542
      HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV):
60543
        VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
60544
        ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60545
        VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
60546
        HYBRID_BREAK();
60547
      HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV):
60548
        VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
60549
        ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60550
        VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
60551
        HYBRID_BREAK();
60552
      HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV):
60553
        VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
60554
        ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60555
        VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
60556
        HYBRID_BREAK();
60557
      HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV):
60558
        VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
60559
        ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60560
        VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
60561
        HYBRID_BREAK();
60562
      HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV):
60563
        VM_TRACE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
60564
        ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60565
        VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
60566
        HYBRID_BREAK();
60567
      HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV):
60568
        VM_TRACE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
60569
        ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60570
        VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
60571
        HYBRID_BREAK();
60572
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV):
60573
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
60574
        ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60575
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
60576
        HYBRID_BREAK();
60577
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60578
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60579
        ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60580
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60581
        HYBRID_BREAK();
60582
      HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60583
        VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60584
        ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60585
        VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60586
        HYBRID_BREAK();
60587
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV):
60588
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
60589
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60590
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
60591
        HYBRID_BREAK();
60592
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60593
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60594
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60595
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60596
        HYBRID_BREAK();
60597
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60598
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60599
        ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60600
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60601
        HYBRID_BREAK();
60602
      HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV):
60603
        VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
60604
        ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60605
        VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
60606
        HYBRID_BREAK();
60607
      HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV):
60608
        VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
60609
        ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60610
        VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
60611
        HYBRID_BREAK();
60612
      HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV):
60613
        VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
60614
        ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60615
        VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
60616
        HYBRID_BREAK();
60617
      HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60618
        VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60619
        ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60620
        VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60621
        HYBRID_BREAK();
60622
      HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV):
60623
        VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
60624
        ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60625
        VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
60626
        HYBRID_BREAK();
60627
      HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60628
        VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60629
        ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60630
        VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60631
        HYBRID_BREAK();
60632
      HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60633
        VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60634
        ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60635
        VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60636
        HYBRID_BREAK();
60637
      HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV):
60638
        VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
60639
        ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60640
        VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
60641
        HYBRID_BREAK();
60642
      HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60643
        VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60644
        ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60645
        VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60646
        HYBRID_BREAK();
60647
      HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60648
        VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60649
        ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60650
        VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60651
        HYBRID_BREAK();
60652
      HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV):
60653
        VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
60654
        ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60655
        VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
60656
        HYBRID_BREAK();
60657
      HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60658
        VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60659
        ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60660
        VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60661
        HYBRID_BREAK();
60662
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60663
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60664
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60665
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60666
        HYBRID_BREAK();
60667
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60668
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60669
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60670
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60671
        HYBRID_BREAK();
60672
      HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60673
        VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60674
        ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60675
        VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60676
        HYBRID_BREAK();
60677
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60678
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60679
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60680
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60681
        HYBRID_BREAK();
60682
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60683
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60684
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60685
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60686
        HYBRID_BREAK();
60687
      HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60688
        VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60689
        ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60690
        VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60691
        HYBRID_BREAK();
60692
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60693
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60694
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60695
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60696
        HYBRID_BREAK();
60697
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60698
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60699
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60700
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60701
        HYBRID_BREAK();
60702
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60703
        VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60704
        ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60705
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60706
        HYBRID_BREAK();
60707
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60708
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60709
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60710
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60711
        HYBRID_BREAK();
60712
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60713
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60714
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60715
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60716
        HYBRID_BREAK();
60717
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60718
        VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60719
        ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60720
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60721
        HYBRID_BREAK();
60722
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV):
60723
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
60724
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60725
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
60726
        HYBRID_BREAK();
60727
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60728
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60729
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60730
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60731
        HYBRID_BREAK();
60732
      HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60733
        VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60734
        ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60735
        VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60736
        HYBRID_BREAK();
60737
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60738
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60739
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60740
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60741
        HYBRID_BREAK();
60742
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60743
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60744
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60745
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60746
        HYBRID_BREAK();
60747
      HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60748
        VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60749
        ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60750
        VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60751
        HYBRID_BREAK();
60752
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60753
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60754
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60755
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60756
        HYBRID_BREAK();
60757
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60758
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60759
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60760
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60761
        HYBRID_BREAK();
60762
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60763
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60764
        ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60765
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60766
        HYBRID_BREAK();
60767
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60768
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60769
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60770
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60771
        HYBRID_BREAK();
60772
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60773
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60774
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60775
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60776
        HYBRID_BREAK();
60777
      HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60778
        VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60779
        ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60780
        VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60781
        HYBRID_BREAK();
60782
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR):
60783
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
60784
        ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60785
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
60786
        HYBRID_BREAK();
60787
      HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED):
60788
        VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
60789
        ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60790
        VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
60791
        HYBRID_BREAK();
60792
      HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV):
60793
        VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
60794
        ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60795
        VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
60796
        HYBRID_BREAK();
60797
      HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR):
60798
        VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR)
60799
        ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60800
        VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR)
60801
        HYBRID_BREAK();
60802
      HYBRID_CASE(ZEND_ECHO_SPEC_TMPVAR):
60803
        VM_TRACE(ZEND_ECHO_SPEC_TMPVAR)
60804
        ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60805
        VM_TRACE_OP_END(ZEND_ECHO_SPEC_TMPVAR)
60806
        HYBRID_BREAK();
60807
      HYBRID_CASE(ZEND_JMPZ_SPEC_TMPVAR):
60808
        VM_TRACE(ZEND_JMPZ_SPEC_TMPVAR)
60809
        ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60810
        VM_TRACE_OP_END(ZEND_JMPZ_SPEC_TMPVAR)
60811
        HYBRID_BREAK();
60812
      HYBRID_CASE(ZEND_JMPNZ_SPEC_TMPVAR):
60813
        VM_TRACE(ZEND_JMPNZ_SPEC_TMPVAR)
60814
        ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60815
        VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_TMPVAR)
60816
        HYBRID_BREAK();
60817
      HYBRID_CASE(ZEND_JMPZ_EX_SPEC_TMPVAR):
60818
        VM_TRACE(ZEND_JMPZ_EX_SPEC_TMPVAR)
60819
        ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60820
        VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_TMPVAR)
60821
        HYBRID_BREAK();
60822
      HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_TMPVAR):
60823
        VM_TRACE(ZEND_JMPNZ_EX_SPEC_TMPVAR)
60824
        ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60825
        VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_TMPVAR)
60826
        HYBRID_BREAK();
60827
      HYBRID_CASE(ZEND_FREE_SPEC_TMPVAR):
60828
        VM_TRACE(ZEND_FREE_SPEC_TMPVAR)
60829
        ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60830
        VM_TRACE_OP_END(ZEND_FREE_SPEC_TMPVAR)
60831
        HYBRID_BREAK();
60832
      HYBRID_CASE(ZEND_FE_FREE_SPEC_TMPVAR):
60833
        VM_TRACE(ZEND_FE_FREE_SPEC_TMPVAR)
60834
        ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60835
        VM_TRACE_OP_END(ZEND_FE_FREE_SPEC_TMPVAR)
60836
        HYBRID_BREAK();
60837
      HYBRID_CASE(ZEND_THROW_SPEC_TMPVAR):
60838
        VM_TRACE(ZEND_THROW_SPEC_TMPVAR)
60839
        ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60840
        VM_TRACE_OP_END(ZEND_THROW_SPEC_TMPVAR)
60841
        HYBRID_BREAK();
60842
      HYBRID_CASE(ZEND_BOOL_SPEC_TMPVAR):
60843
        VM_TRACE(ZEND_BOOL_SPEC_TMPVAR)
60844
        ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60845
        VM_TRACE_OP_END(ZEND_BOOL_SPEC_TMPVAR)
60846
        HYBRID_BREAK();
60847
      HYBRID_CASE(ZEND_CLONE_SPEC_TMPVAR):
60848
        VM_TRACE(ZEND_CLONE_SPEC_TMPVAR)
60849
        ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60850
        VM_TRACE_OP_END(ZEND_CLONE_SPEC_TMPVAR)
60851
        HYBRID_BREAK();
60852
      HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR):
60853
        VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
60854
        ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60855
        VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
60856
        HYBRID_BREAK();
60857
      HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR):
60858
        VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR)
60859
        ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60860
        VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_TMPVAR)
60861
        HYBRID_BREAK();
60862
      HYBRID_CASE(ZEND_STRLEN_SPEC_TMPVAR):
60863
        VM_TRACE(ZEND_STRLEN_SPEC_TMPVAR)
60864
        ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60865
        VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMPVAR)
60866
        HYBRID_BREAK();
60867
      HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR):
60868
        VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR)
60869
        ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60870
        VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR)
60871
        HYBRID_BREAK();
60872
      HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR):
60873
        VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
60874
        ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60875
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
60876
        HYBRID_BREAK();
60877
      HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CONST):
60878
        VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CONST)
60879
        ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60880
        VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CONST)
60881
        HYBRID_BREAK();
60882
      HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CONST):
60883
        VM_TRACE(ZEND_POW_SPEC_TMPVAR_CONST)
60884
        ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60885
        VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CONST)
60886
        HYBRID_BREAK();
60887
      HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CONST):
60888
        VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CONST)
60889
        ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60890
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CONST)
60891
        HYBRID_BREAK();
60892
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST):
60893
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
60894
        ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60895
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
60896
        HYBRID_BREAK();
60897
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
60898
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60899
        ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60900
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60901
        HYBRID_BREAK();
60902
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
60903
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60904
        ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60905
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60906
        HYBRID_BREAK();
60907
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST):
60908
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
60909
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60910
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
60911
        HYBRID_BREAK();
60912
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
60913
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60914
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60915
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60916
        HYBRID_BREAK();
60917
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
60918
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60919
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60920
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60921
        HYBRID_BREAK();
60922
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST):
60923
        VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
60924
        ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60925
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
60926
        HYBRID_BREAK();
60927
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST):
60928
        VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
60929
        ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60930
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
60931
        HYBRID_BREAK();
60932
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST):
60933
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
60934
        ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60935
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
60936
        HYBRID_BREAK();
60937
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST):
60938
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
60939
        ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60940
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
60941
        HYBRID_BREAK();
60942
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST):
60943
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
60944
        ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60945
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
60946
        HYBRID_BREAK();
60947
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST):
60948
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
60949
        ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60950
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
60951
        HYBRID_BREAK();
60952
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST):
60953
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
60954
        ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60955
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
60956
        HYBRID_BREAK();
60957
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST):
60958
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
60959
        ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60960
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
60961
        HYBRID_BREAK();
60962
      HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST):
60963
        VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
60964
        ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60965
        VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
60966
        HYBRID_BREAK();
60967
      HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CONST):
60968
        VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CONST)
60969
        ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60970
        VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CONST)
60971
        HYBRID_BREAK();
60972
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST):
60973
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
60974
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60975
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
60976
        HYBRID_BREAK();
60977
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST):
60978
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
60979
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60980
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
60981
        HYBRID_BREAK();
60982
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST):
60983
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
60984
        ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60985
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
60986
        HYBRID_BREAK();
60987
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST):
60988
        VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
60989
        ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60990
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
60991
        HYBRID_BREAK();
60992
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST):
60993
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
60994
        ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60995
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
60996
        HYBRID_BREAK();
60997
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV):
60998
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
60999
        ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61000
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
61001
        HYBRID_BREAK();
61002
      HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_TMPVAR):
61003
        VM_TRACE(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
61004
        ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61005
        VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
61006
        HYBRID_BREAK();
61007
      HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_TMPVAR):
61008
        VM_TRACE(ZEND_POW_SPEC_TMPVAR_TMPVAR)
61009
        ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61010
        VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_TMPVAR)
61011
        HYBRID_BREAK();
61012
      HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR):
61013
        VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
61014
        ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61015
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
61016
        HYBRID_BREAK();
61017
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR):
61018
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
61019
        ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61020
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
61021
        HYBRID_BREAK();
61022
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
61023
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
61024
        ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61025
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
61026
        HYBRID_BREAK();
61027
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
61028
        VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
61029
        ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61030
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
61031
        HYBRID_BREAK();
61032
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR):
61033
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
61034
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61035
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
61036
        HYBRID_BREAK();
61037
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
61038
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
61039
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61040
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
61041
        HYBRID_BREAK();
61042
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
61043
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
61044
        ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61045
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
61046
        HYBRID_BREAK();
61047
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR):
61048
        VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
61049
        ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61050
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
61051
        HYBRID_BREAK();
61052
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR):
61053
        VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
61054
        ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61055
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
61056
        HYBRID_BREAK();
61057
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR):
61058
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
61059
        ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61060
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
61061
        HYBRID_BREAK();
61062
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR):
61063
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
61064
        ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61065
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
61066
        HYBRID_BREAK();
61067
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR):
61068
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
61069
        ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61070
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
61071
        HYBRID_BREAK();
61072
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR):
61073
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
61074
        ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61075
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
61076
        HYBRID_BREAK();
61077
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR):
61078
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
61079
        ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61080
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
61081
        HYBRID_BREAK();
61082
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR):
61083
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
61084
        ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61085
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
61086
        HYBRID_BREAK();
61087
      HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR):
61088
        VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
61089
        ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61090
        VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
61091
        HYBRID_BREAK();
61092
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR):
61093
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
61094
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61095
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
61096
        HYBRID_BREAK();
61097
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR):
61098
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
61099
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61100
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
61101
        HYBRID_BREAK();
61102
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR):
61103
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
61104
        ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61105
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
61106
        HYBRID_BREAK();
61107
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR):
61108
        VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
61109
        ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61110
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
61111
        HYBRID_BREAK();
61112
      HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED):
61113
        VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
61114
        ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61115
        VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
61116
        HYBRID_BREAK();
61117
      HYBRID_CASE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED):
61118
        VM_TRACE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
61119
        ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61120
        VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
61121
        HYBRID_BREAK();
61122
      HYBRID_CASE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED):
61123
        VM_TRACE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
61124
        ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61125
        VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
61126
        HYBRID_BREAK();
61127
      HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED):
61128
        VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
61129
        ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61130
        VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
61131
        HYBRID_BREAK();
61132
      HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED):
61133
        VM_TRACE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
61134
        ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61135
        VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
61136
        HYBRID_BREAK();
61137
      HYBRID_CASE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED):
61138
        VM_TRACE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
61139
        ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61140
        VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
61141
        HYBRID_BREAK();
61142
      HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED):
61143
        VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
61144
        ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61145
        VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
61146
        HYBRID_BREAK();
61147
      HYBRID_CASE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED):
61148
        VM_TRACE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
61149
        ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61150
        VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
61151
        HYBRID_BREAK();
61152
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED):
61153
        VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
61154
        ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61155
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
61156
        HYBRID_BREAK();
61157
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED):
61158
        VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
61159
        ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61160
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
61161
        HYBRID_BREAK();
61162
      HYBRID_CASE(ZEND_COUNT_SPEC_TMPVAR_UNUSED):
61163
        VM_TRACE(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
61164
        ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61165
        VM_TRACE_OP_END(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
61166
        HYBRID_BREAK();
61167
      HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED):
61168
        VM_TRACE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
61169
        ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61170
        VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
61171
        HYBRID_BREAK();
61172
      HYBRID_CASE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED):
61173
        VM_TRACE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
61174
        ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61175
        VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
61176
        HYBRID_BREAK();
61177
      HYBRID_CASE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED):
61178
        VM_TRACE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
61179
        ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61180
        VM_TRACE_OP_END(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
61181
        HYBRID_BREAK();
61182
      HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CV):
61183
        VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CV)
61184
        ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61185
        VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CV)
61186
        HYBRID_BREAK();
61187
      HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CV):
61188
        VM_TRACE(ZEND_POW_SPEC_TMPVAR_CV)
61189
        ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61190
        VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CV)
61191
        HYBRID_BREAK();
61192
      HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CV):
61193
        VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CV)
61194
        ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61195
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CV)
61196
        HYBRID_BREAK();
61197
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CV):
61198
        VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
61199
        ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61200
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
61201
        HYBRID_BREAK();
61202
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV):
61203
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
61204
        ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61205
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
61206
        HYBRID_BREAK();
61207
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV):
61208
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
61209
        ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61210
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
61211
        HYBRID_BREAK();
61212
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV):
61213
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
61214
        ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61215
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
61216
        HYBRID_BREAK();
61217
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV):
61218
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
61219
        ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61220
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
61221
        HYBRID_BREAK();
61222
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV):
61223
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
61224
        ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61225
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
61226
        HYBRID_BREAK();
61227
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV):
61228
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
61229
        ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61230
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
61231
        HYBRID_BREAK();
61232
      HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV):
61233
        VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV)
61234
        ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61235
        VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CV)
61236
        HYBRID_BREAK();
61237
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV):
61238
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
61239
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61240
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
61241
        HYBRID_BREAK();
61242
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV):
61243
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
61244
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61245
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
61246
        HYBRID_BREAK();
61247
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV):
61248
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
61249
        ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61250
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
61251
        HYBRID_BREAK();
61252
      HYBRID_CASE(ZEND_RETURN_SPEC_TMP):
61253
        VM_TRACE(ZEND_RETURN_SPEC_TMP)
61254
{
61255
  USE_OPLINE
61256
  zval *retval_ptr;
61257
  zval *return_value;
61258
61259
  retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
61260
  return_value = EX(return_value);
61261
61262
  if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61263
    SAVE_OPLINE();
61264
    retval_ptr = ZVAL_UNDEFINED_OP1();
61265
    if (return_value) {
61266
      ZVAL_NULL(return_value);
61267
    }
61268
  } else if (!return_value) {
61269
    if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
61270
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61271
        SAVE_OPLINE();
61272
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
61273
      }
61274
    }
61275
  } else {
61276
    if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
61277
      ZVAL_COPY_VALUE(return_value, retval_ptr);
61278
      if (IS_TMP_VAR == IS_CONST) {
61279
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61280
          Z_ADDREF_P(return_value);
61281
        }
61282
      }
61283
    } else if (IS_TMP_VAR == IS_CV) {
61284
      do {
61285
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61286
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61287
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61288
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61289
              ZVAL_COPY_VALUE(return_value, retval_ptr);
61290
              if (GC_MAY_LEAK(ref)) {
61291
                SAVE_OPLINE();
61292
                gc_possible_root(ref);
61293
              }
61294
              ZVAL_NULL(retval_ptr);
61295
              break;
61296
            } else {
61297
              Z_ADDREF_P(retval_ptr);
61298
            }
61299
          } else {
61300
            retval_ptr = Z_REFVAL_P(retval_ptr);
61301
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61302
              Z_ADDREF_P(retval_ptr);
61303
            }
61304
          }
61305
        }
61306
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61307
      } while (0);
61308
    } else /* if (IS_TMP_VAR == IS_VAR) */ {
61309
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61310
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61311
61312
        retval_ptr = Z_REFVAL_P(retval_ptr);
61313
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61314
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61315
          efree_size(ref, sizeof(zend_reference));
61316
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61317
          Z_ADDREF_P(retval_ptr);
61318
        }
61319
      } else {
61320
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61321
      }
61322
    }
61323
  }
61324
61325
61326
61327
  goto zend_leave_helper_SPEC_LABEL;
61328
}
61329
61330
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_TMP)
61331
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_TMP):
61332
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP)
61333
        ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61334
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_TMP)
61335
        HYBRID_BREAK();
61336
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP):
61337
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP)
61338
        ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61339
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_TMP)
61340
        HYBRID_BREAK();
61341
      HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP):
61342
        VM_TRACE(ZEND_SEND_USER_SPEC_TMP)
61343
        ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61344
        VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP)
61345
        HYBRID_BREAK();
61346
      HYBRID_CASE(ZEND_CAST_SPEC_TMP):
61347
        VM_TRACE(ZEND_CAST_SPEC_TMP)
61348
        ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61349
        VM_TRACE_OP_END(ZEND_CAST_SPEC_TMP)
61350
        HYBRID_BREAK();
61351
      HYBRID_CASE(ZEND_FE_RESET_R_SPEC_TMP):
61352
        VM_TRACE(ZEND_FE_RESET_R_SPEC_TMP)
61353
        ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61354
        VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_TMP)
61355
        HYBRID_BREAK();
61356
      HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_TMP):
61357
        VM_TRACE(ZEND_FE_RESET_RW_SPEC_TMP)
61358
        ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61359
        VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_TMP)
61360
        HYBRID_BREAK();
61361
      HYBRID_CASE(ZEND_END_SILENCE_SPEC_TMP):
61362
        VM_TRACE(ZEND_END_SILENCE_SPEC_TMP)
61363
        ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61364
        VM_TRACE_OP_END(ZEND_END_SILENCE_SPEC_TMP)
61365
        HYBRID_BREAK();
61366
      HYBRID_CASE(ZEND_JMP_SET_SPEC_TMP):
61367
        VM_TRACE(ZEND_JMP_SET_SPEC_TMP)
61368
        ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61369
        VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_TMP)
61370
        HYBRID_BREAK();
61371
      HYBRID_CASE(ZEND_COALESCE_SPEC_TMP):
61372
        VM_TRACE(ZEND_COALESCE_SPEC_TMP)
61373
        ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61374
        VM_TRACE_OP_END(ZEND_COALESCE_SPEC_TMP)
61375
        HYBRID_BREAK();
61376
      HYBRID_CASE(ZEND_JMP_NULL_SPEC_TMP):
61377
        VM_TRACE(ZEND_JMP_NULL_SPEC_TMP)
61378
        ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61379
        VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_TMP)
61380
        HYBRID_BREAK();
61381
      HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_TMP):
61382
        VM_TRACE(ZEND_QM_ASSIGN_SPEC_TMP)
61383
        ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61384
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_TMP)
61385
        HYBRID_BREAK();
61386
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST):
61387
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
61388
        ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61389
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
61390
        HYBRID_BREAK();
61391
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CONST):
61392
        VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CONST)
61393
        ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61394
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CONST)
61395
        HYBRID_BREAK();
61396
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST):
61397
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
61398
        ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61399
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
61400
        HYBRID_BREAK();
61401
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST):
61402
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
61403
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61404
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
61405
        HYBRID_BREAK();
61406
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST):
61407
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
61408
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61409
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
61410
        HYBRID_BREAK();
61411
      HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CONST):
61412
        VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CONST)
61413
        ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61414
        VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CONST)
61415
        HYBRID_BREAK();
61416
      HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CONST):
61417
        VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CONST)
61418
        ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61419
        VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CONST)
61420
        HYBRID_BREAK();
61421
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST):
61422
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
61423
        ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61424
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
61425
        HYBRID_BREAK();
61426
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST):
61427
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
61428
        ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61429
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
61430
        HYBRID_BREAK();
61431
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CONST):
61432
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
61433
        ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61434
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
61435
        HYBRID_BREAK();
61436
      HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CONST):
61437
        VM_TRACE(ZEND_YIELD_SPEC_TMP_CONST)
61438
        ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61439
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CONST)
61440
        HYBRID_BREAK();
61441
      HYBRID_CASE(ZEND_IN_ARRAY_SPEC_TMP_CONST):
61442
        VM_TRACE(ZEND_IN_ARRAY_SPEC_TMP_CONST)
61443
        ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61444
        VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_TMP_CONST)
61445
        HYBRID_BREAK();
61446
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR):
61447
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
61448
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61449
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
61450
        HYBRID_BREAK();
61451
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR):
61452
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
61453
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61454
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
61455
        HYBRID_BREAK();
61456
      HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR):
61457
        VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
61458
        ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61459
        VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
61460
        HYBRID_BREAK();
61461
      HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_TMPVAR):
61462
        VM_TRACE(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
61463
        ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61464
        VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
61465
        HYBRID_BREAK();
61466
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR):
61467
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
61468
        ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61469
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
61470
        HYBRID_BREAK();
61471
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR):
61472
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
61473
        ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61474
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
61475
        HYBRID_BREAK();
61476
      HYBRID_CASE(ZEND_YIELD_SPEC_TMP_TMPVAR):
61477
        VM_TRACE(ZEND_YIELD_SPEC_TMP_TMPVAR)
61478
        ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61479
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_TMPVAR)
61480
        HYBRID_BREAK();
61481
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP):
61482
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
61483
        ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61484
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
61485
        HYBRID_BREAK();
61486
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_TMP):
61487
        VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_TMP)
61488
        ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61489
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_TMP)
61490
        HYBRID_BREAK();
61491
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP):
61492
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
61493
        ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61494
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
61495
        HYBRID_BREAK();
61496
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_VAR):
61497
        VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_VAR)
61498
        ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61499
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_VAR)
61500
        HYBRID_BREAK();
61501
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED):
61502
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
61503
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61504
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
61505
        HYBRID_BREAK();
61506
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED):
61507
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
61508
        ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61509
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
61510
        HYBRID_BREAK();
61511
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED):
61512
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
61513
        ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61514
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
61515
        HYBRID_BREAK();
61516
      HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK):
61517
        VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
61518
        ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61519
        VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
61520
        HYBRID_BREAK();
61521
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED):
61522
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
61523
        ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61524
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
61525
        HYBRID_BREAK();
61526
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED):
61527
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
61528
        ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61529
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
61530
        HYBRID_BREAK();
61531
      HYBRID_CASE(ZEND_YIELD_SPEC_TMP_UNUSED):
61532
        VM_TRACE(ZEND_YIELD_SPEC_TMP_UNUSED)
61533
        ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61534
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_UNUSED)
61535
        HYBRID_BREAK();
61536
      HYBRID_CASE(ZEND_GET_TYPE_SPEC_TMP_UNUSED):
61537
        VM_TRACE(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
61538
        ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61539
        VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
61540
        HYBRID_BREAK();
61541
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV):
61542
        VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV)
61543
        ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61544
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CV)
61545
        HYBRID_BREAK();
61546
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV):
61547
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
61548
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61549
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
61550
        HYBRID_BREAK();
61551
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV):
61552
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
61553
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61554
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
61555
        HYBRID_BREAK();
61556
      HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CV):
61557
        VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CV)
61558
        ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61559
        VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CV)
61560
        HYBRID_BREAK();
61561
      HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CV):
61562
        VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CV)
61563
        ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61564
        VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CV)
61565
        HYBRID_BREAK();
61566
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV):
61567
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
61568
        ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61569
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
61570
        HYBRID_BREAK();
61571
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CV):
61572
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CV)
61573
        ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61574
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CV)
61575
        HYBRID_BREAK();
61576
      HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CV):
61577
        VM_TRACE(ZEND_YIELD_SPEC_TMP_CV)
61578
        ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61579
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CV)
61580
        HYBRID_BREAK();
61581
      HYBRID_CASE(ZEND_BIND_LEXICAL_SPEC_TMP_CV):
61582
        VM_TRACE(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
61583
        ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61584
        VM_TRACE_OP_END(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
61585
        HYBRID_BREAK();
61586
      HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED):
61587
        VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
61588
        ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61589
        VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
61590
        HYBRID_BREAK();
61591
      HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED):
61592
        VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
61593
        ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61594
        VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
61595
        HYBRID_BREAK();
61596
      HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED):
61597
        VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
61598
        ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61599
        VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
61600
        HYBRID_BREAK();
61601
      HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED):
61602
        VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
61603
        ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61604
        VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
61605
        HYBRID_BREAK();
61606
      HYBRID_CASE(ZEND_POST_INC_SPEC_VAR):
61607
        VM_TRACE(ZEND_POST_INC_SPEC_VAR)
61608
        ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61609
        VM_TRACE_OP_END(ZEND_POST_INC_SPEC_VAR)
61610
        HYBRID_BREAK();
61611
      HYBRID_CASE(ZEND_POST_DEC_SPEC_VAR):
61612
        VM_TRACE(ZEND_POST_DEC_SPEC_VAR)
61613
        ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61614
        VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_VAR)
61615
        HYBRID_BREAK();
61616
      HYBRID_CASE(ZEND_RETURN_SPEC_VAR):
61617
        VM_TRACE(ZEND_RETURN_SPEC_VAR)
61618
{
61619
  USE_OPLINE
61620
  zval *retval_ptr;
61621
  zval *return_value;
61622
61623
  retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
61624
  return_value = EX(return_value);
61625
61626
  if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61627
    SAVE_OPLINE();
61628
    retval_ptr = ZVAL_UNDEFINED_OP1();
61629
    if (return_value) {
61630
      ZVAL_NULL(return_value);
61631
    }
61632
  } else if (!return_value) {
61633
    if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
61634
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61635
        SAVE_OPLINE();
61636
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
61637
      }
61638
    }
61639
  } else {
61640
    if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
61641
      ZVAL_COPY_VALUE(return_value, retval_ptr);
61642
      if (IS_VAR == IS_CONST) {
61643
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61644
          Z_ADDREF_P(return_value);
61645
        }
61646
      }
61647
    } else if (IS_VAR == IS_CV) {
61648
      do {
61649
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61650
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61651
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61652
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61653
              ZVAL_COPY_VALUE(return_value, retval_ptr);
61654
              if (GC_MAY_LEAK(ref)) {
61655
                SAVE_OPLINE();
61656
                gc_possible_root(ref);
61657
              }
61658
              ZVAL_NULL(retval_ptr);
61659
              break;
61660
            } else {
61661
              Z_ADDREF_P(retval_ptr);
61662
            }
61663
          } else {
61664
            retval_ptr = Z_REFVAL_P(retval_ptr);
61665
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61666
              Z_ADDREF_P(retval_ptr);
61667
            }
61668
          }
61669
        }
61670
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61671
      } while (0);
61672
    } else /* if (IS_VAR == IS_VAR) */ {
61673
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61674
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61675
61676
        retval_ptr = Z_REFVAL_P(retval_ptr);
61677
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61678
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61679
          efree_size(ref, sizeof(zend_reference));
61680
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61681
          Z_ADDREF_P(retval_ptr);
61682
        }
61683
      } else {
61684
        ZVAL_COPY_VALUE(return_value, retval_ptr);
61685
      }
61686
    }
61687
  }
61688
61689
61690
61691
  goto zend_leave_helper_SPEC_LABEL;
61692
}
61693
61694
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_VAR)
61695
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR):
61696
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR)
61697
        ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61698
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_VAR)
61699
        HYBRID_BREAK();
61700
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR):
61701
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR)
61702
        ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61703
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_VAR)
61704
        HYBRID_BREAK();
61705
      HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR):
61706
        VM_TRACE(ZEND_SEND_USER_SPEC_VAR)
61707
        ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61708
        VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_VAR)
61709
        HYBRID_BREAK();
61710
      HYBRID_CASE(ZEND_CAST_SPEC_VAR):
61711
        VM_TRACE(ZEND_CAST_SPEC_VAR)
61712
        ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61713
        VM_TRACE_OP_END(ZEND_CAST_SPEC_VAR)
61714
        HYBRID_BREAK();
61715
      HYBRID_CASE(ZEND_FE_RESET_R_SPEC_VAR):
61716
        VM_TRACE(ZEND_FE_RESET_R_SPEC_VAR)
61717
        ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61718
        VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_VAR)
61719
        HYBRID_BREAK();
61720
      HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_VAR):
61721
        VM_TRACE(ZEND_FE_RESET_RW_SPEC_VAR)
61722
        ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61723
        VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_VAR)
61724
        HYBRID_BREAK();
61725
      HYBRID_CASE(ZEND_FE_FETCH_R_SPEC_VAR):
61726
        VM_TRACE(ZEND_FE_FETCH_R_SPEC_VAR)
61727
        ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61728
        VM_TRACE_OP_END(ZEND_FE_FETCH_R_SPEC_VAR)
61729
        HYBRID_BREAK();
61730
      HYBRID_CASE(ZEND_FE_FETCH_RW_SPEC_VAR):
61731
        VM_TRACE(ZEND_FE_FETCH_RW_SPEC_VAR)
61732
        ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61733
        VM_TRACE_OP_END(ZEND_FE_FETCH_RW_SPEC_VAR)
61734
        HYBRID_BREAK();
61735
      HYBRID_CASE(ZEND_JMP_SET_SPEC_VAR):
61736
        VM_TRACE(ZEND_JMP_SET_SPEC_VAR)
61737
        ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61738
        VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_VAR)
61739
        HYBRID_BREAK();
61740
      HYBRID_CASE(ZEND_COALESCE_SPEC_VAR):
61741
        VM_TRACE(ZEND_COALESCE_SPEC_VAR)
61742
        ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61743
        VM_TRACE_OP_END(ZEND_COALESCE_SPEC_VAR)
61744
        HYBRID_BREAK();
61745
      HYBRID_CASE(ZEND_JMP_NULL_SPEC_VAR):
61746
        VM_TRACE(ZEND_JMP_NULL_SPEC_VAR)
61747
        ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61748
        VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_VAR)
61749
        HYBRID_BREAK();
61750
      HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_VAR):
61751
        VM_TRACE(ZEND_QM_ASSIGN_SPEC_VAR)
61752
        ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61753
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_VAR)
61754
        HYBRID_BREAK();
61755
      HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR):
61756
        VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
61757
        ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61758
        VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
61759
        HYBRID_BREAK();
61760
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST):
61761
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
61762
        ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61763
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
61764
        HYBRID_BREAK();
61765
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CONST):
61766
        VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CONST)
61767
        ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61768
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CONST)
61769
        HYBRID_BREAK();
61770
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST):
61771
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
61772
        ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61773
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
61774
        HYBRID_BREAK();
61775
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST):
61776
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
61777
        ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61778
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
61779
        HYBRID_BREAK();
61780
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST):
61781
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
61782
        ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61783
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
61784
        HYBRID_BREAK();
61785
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CONST):
61786
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
61787
        ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61788
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
61789
        HYBRID_BREAK();
61790
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST):
61791
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
61792
        ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61793
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
61794
        HYBRID_BREAK();
61795
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST):
61796
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
61797
        ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61798
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
61799
        HYBRID_BREAK();
61800
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST):
61801
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
61802
        ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61803
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
61804
        HYBRID_BREAK();
61805
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST):
61806
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
61807
        ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61808
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
61809
        HYBRID_BREAK();
61810
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST):
61811
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
61812
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61813
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
61814
        HYBRID_BREAK();
61815
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST):
61816
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
61817
        ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61818
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
61819
        HYBRID_BREAK();
61820
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST):
61821
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
61822
        ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61823
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
61824
        HYBRID_BREAK();
61825
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST):
61826
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
61827
        ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61828
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
61829
        HYBRID_BREAK();
61830
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST):
61831
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
61832
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61833
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
61834
        HYBRID_BREAK();
61835
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST):
61836
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
61837
        ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61838
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
61839
        HYBRID_BREAK();
61840
      HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST):
61841
        VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
61842
        ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61843
        VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
61844
        HYBRID_BREAK();
61845
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST):
61846
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
61847
        ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61848
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
61849
        HYBRID_BREAK();
61850
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP):
61851
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
61852
        ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61853
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
61854
        HYBRID_BREAK();
61855
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR):
61856
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
61857
        ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61858
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
61859
        HYBRID_BREAK();
61860
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV):
61861
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
61862
        ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61863
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
61864
        HYBRID_BREAK();
61865
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST):
61866
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
61867
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61868
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
61869
        HYBRID_BREAK();
61870
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP):
61871
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
61872
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61873
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
61874
        HYBRID_BREAK();
61875
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR):
61876
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
61877
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61878
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
61879
        HYBRID_BREAK();
61880
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV):
61881
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
61882
        ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61883
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
61884
        HYBRID_BREAK();
61885
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED):
61886
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
61887
        ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61888
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
61889
        HYBRID_BREAK();
61890
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED):
61891
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
61892
        ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61893
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
61894
        HYBRID_BREAK();
61895
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR):
61896
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
61897
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61898
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
61899
        HYBRID_BREAK();
61900
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV):
61901
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
61902
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61903
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
61904
        HYBRID_BREAK();
61905
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST):
61906
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
61907
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61908
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
61909
        HYBRID_BREAK();
61910
      HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST):
61911
        VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST)
61912
        ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61913
        VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_CONST)
61914
        HYBRID_BREAK();
61915
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST):
61916
        VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
61917
        ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61918
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
61919
        HYBRID_BREAK();
61920
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST):
61921
        VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
61922
        ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61923
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
61924
        HYBRID_BREAK();
61925
      HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_CONST):
61926
        VM_TRACE(ZEND_SEND_REF_SPEC_VAR_CONST)
61927
        ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61928
        VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_CONST)
61929
        HYBRID_BREAK();
61930
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST):
61931
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
61932
        ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61933
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
61934
        HYBRID_BREAK();
61935
      HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST):
61936
        VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
61937
        ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61938
        VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
61939
        HYBRID_BREAK();
61940
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST):
61941
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
61942
        ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61943
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
61944
        HYBRID_BREAK();
61945
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST):
61946
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
61947
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61948
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
61949
        HYBRID_BREAK();
61950
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CONST):
61951
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
61952
        ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61953
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
61954
        HYBRID_BREAK();
61955
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CONST):
61956
        VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CONST)
61957
        ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61958
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CONST)
61959
        HYBRID_BREAK();
61960
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CONST):
61961
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
61962
        ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61963
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
61964
        HYBRID_BREAK();
61965
      HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CONST):
61966
        VM_TRACE(ZEND_YIELD_SPEC_VAR_CONST)
61967
        ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61968
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CONST)
61969
        HYBRID_BREAK();
61970
      HYBRID_CASE(ZEND_IN_ARRAY_SPEC_VAR_CONST):
61971
        VM_TRACE(ZEND_IN_ARRAY_SPEC_VAR_CONST)
61972
        ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61973
        VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_VAR_CONST)
61974
        HYBRID_BREAK();
61975
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV):
61976
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
61977
        ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61978
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
61979
        HYBRID_BREAK();
61980
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR):
61981
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
61982
        ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61983
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
61984
        HYBRID_BREAK();
61985
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR):
61986
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
61987
        ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61988
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
61989
        HYBRID_BREAK();
61990
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR):
61991
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
61992
        ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61993
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
61994
        HYBRID_BREAK();
61995
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR):
61996
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
61997
        ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61998
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
61999
        HYBRID_BREAK();
62000
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR):
62001
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
62002
        ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62003
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
62004
        HYBRID_BREAK();
62005
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR):
62006
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
62007
        ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62008
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
62009
        HYBRID_BREAK();
62010
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR):
62011
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
62012
        ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62013
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
62014
        HYBRID_BREAK();
62015
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR):
62016
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
62017
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62018
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
62019
        HYBRID_BREAK();
62020
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR):
62021
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
62022
        ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62023
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
62024
        HYBRID_BREAK();
62025
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR):
62026
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
62027
        ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62028
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
62029
        HYBRID_BREAK();
62030
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR):
62031
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
62032
        ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62033
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
62034
        HYBRID_BREAK();
62035
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR):
62036
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
62037
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62038
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
62039
        HYBRID_BREAK();
62040
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR):
62041
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
62042
        ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62043
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
62044
        HYBRID_BREAK();
62045
      HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR):
62046
        VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
62047
        ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62048
        VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
62049
        HYBRID_BREAK();
62050
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST):
62051
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
62052
        ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62053
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
62054
        HYBRID_BREAK();
62055
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP):
62056
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
62057
        ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62058
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
62059
        HYBRID_BREAK();
62060
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR):
62061
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62062
        ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62063
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62064
        HYBRID_BREAK();
62065
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV):
62066
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
62067
        ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62068
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
62069
        HYBRID_BREAK();
62070
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST):
62071
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
62072
        ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62073
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
62074
        HYBRID_BREAK();
62075
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP):
62076
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
62077
        ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62078
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
62079
        HYBRID_BREAK();
62080
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR):
62081
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62082
        ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62083
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62084
        HYBRID_BREAK();
62085
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV):
62086
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
62087
        ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62088
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
62089
        HYBRID_BREAK();
62090
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR):
62091
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62092
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62093
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
62094
        HYBRID_BREAK();
62095
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV):
62096
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
62097
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62098
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
62099
        HYBRID_BREAK();
62100
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR):
62101
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
62102
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62103
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
62104
        HYBRID_BREAK();
62105
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR):
62106
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
62107
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62108
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
62109
        HYBRID_BREAK();
62110
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR):
62111
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
62112
        ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62113
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
62114
        HYBRID_BREAK();
62115
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR):
62116
        VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
62117
        ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62118
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
62119
        HYBRID_BREAK();
62120
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR):
62121
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
62122
        ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62123
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
62124
        HYBRID_BREAK();
62125
      HYBRID_CASE(ZEND_YIELD_SPEC_VAR_TMPVAR):
62126
        VM_TRACE(ZEND_YIELD_SPEC_VAR_TMPVAR)
62127
        ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62128
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_TMPVAR)
62129
        HYBRID_BREAK();
62130
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP):
62131
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
62132
        ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62133
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
62134
        HYBRID_BREAK();
62135
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_TMP):
62136
        VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_TMP)
62137
        ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62138
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_TMP)
62139
        HYBRID_BREAK();
62140
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP):
62141
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
62142
        ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62143
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
62144
        HYBRID_BREAK();
62145
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED):
62146
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
62147
        ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62148
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
62149
        HYBRID_BREAK();
62150
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED):
62151
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
62152
        ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62153
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
62154
        HYBRID_BREAK();
62155
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR):
62156
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
62157
        ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62158
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
62159
        HYBRID_BREAK();
62160
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_VAR):
62161
        VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_VAR)
62162
        ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62163
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_VAR)
62164
        HYBRID_BREAK();
62165
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR):
62166
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
62167
        ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62168
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
62169
        HYBRID_BREAK();
62170
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED):
62171
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
62172
        ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62173
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
62174
        HYBRID_BREAK();
62175
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED):
62176
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
62177
        ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62178
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
62179
        HYBRID_BREAK();
62180
      HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_VAR):
62181
        VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
62182
        ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62183
        VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
62184
        HYBRID_BREAK();
62185
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED):
62186
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
62187
        ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62188
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
62189
        HYBRID_BREAK();
62190
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED):
62191
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
62192
        ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62193
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
62194
        HYBRID_BREAK();
62195
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED):
62196
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
62197
        ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62198
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
62199
        HYBRID_BREAK();
62200
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED):
62201
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
62202
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62203
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
62204
        HYBRID_BREAK();
62205
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST):
62206
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
62207
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62208
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
62209
        HYBRID_BREAK();
62210
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP):
62211
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
62212
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62213
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
62214
        HYBRID_BREAK();
62215
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR):
62216
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
62217
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62218
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
62219
        HYBRID_BREAK();
62220
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV):
62221
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
62222
        ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62223
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
62224
        HYBRID_BREAK();
62225
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED):
62226
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
62227
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62228
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
62229
        HYBRID_BREAK();
62230
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED):
62231
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
62232
        ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62233
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
62234
        HYBRID_BREAK();
62235
      HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_UNUSED):
62236
        VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
62237
        ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62238
        VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
62239
        HYBRID_BREAK();
62240
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED):
62241
        VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
62242
        ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62243
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
62244
        HYBRID_BREAK();
62245
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED):
62246
        VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
62247
        ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62248
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
62249
        HYBRID_BREAK();
62250
      HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK):
62251
        VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
62252
        ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62253
        VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
62254
        HYBRID_BREAK();
62255
      HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_UNUSED):
62256
        VM_TRACE(ZEND_SEND_REF_SPEC_VAR_UNUSED)
62257
        ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62258
        VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_UNUSED)
62259
        HYBRID_BREAK();
62260
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED):
62261
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
62262
        ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62263
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
62264
        HYBRID_BREAK();
62265
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK):
62266
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
62267
        ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62268
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
62269
        HYBRID_BREAK();
62270
      HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED):
62271
        VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
62272
        ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62273
        VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
62274
        HYBRID_BREAK();
62275
      HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED):
62276
        VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED)
62277
        ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62278
        VM_TRACE_OP_END(ZEND_NEW_SPEC_VAR_UNUSED)
62279
        HYBRID_BREAK();
62280
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED):
62281
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
62282
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62283
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
62284
        HYBRID_BREAK();
62285
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED):
62286
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
62287
        ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62288
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
62289
        HYBRID_BREAK();
62290
      HYBRID_CASE(ZEND_SEPARATE_SPEC_VAR_UNUSED):
62291
        VM_TRACE(ZEND_SEPARATE_SPEC_VAR_UNUSED)
62292
        ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62293
        VM_TRACE_OP_END(ZEND_SEPARATE_SPEC_VAR_UNUSED)
62294
        HYBRID_BREAK();
62295
      HYBRID_CASE(ZEND_YIELD_SPEC_VAR_UNUSED):
62296
        VM_TRACE(ZEND_YIELD_SPEC_VAR_UNUSED)
62297
        ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62298
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_UNUSED)
62299
        HYBRID_BREAK();
62300
      HYBRID_CASE(ZEND_MAKE_REF_SPEC_VAR_UNUSED):
62301
        VM_TRACE(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
62302
        ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62303
        VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
62304
        HYBRID_BREAK();
62305
      HYBRID_CASE(ZEND_GET_TYPE_SPEC_VAR_UNUSED):
62306
        VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
62307
        ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62308
        VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
62309
        HYBRID_BREAK();
62310
      HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED):
62311
        VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
62312
        ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62313
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
62314
        HYBRID_BREAK();
62315
      HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV):
62316
        VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV)
62317
        ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62318
        VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CV)
62319
        HYBRID_BREAK();
62320
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV):
62321
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
62322
        ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62323
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
62324
        HYBRID_BREAK();
62325
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV):
62326
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
62327
        ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62328
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
62329
        HYBRID_BREAK();
62330
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CV):
62331
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CV)
62332
        ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62333
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CV)
62334
        HYBRID_BREAK();
62335
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV):
62336
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
62337
        ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62338
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
62339
        HYBRID_BREAK();
62340
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CV):
62341
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
62342
        ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62343
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
62344
        HYBRID_BREAK();
62345
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CV):
62346
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
62347
        ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62348
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
62349
        HYBRID_BREAK();
62350
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV):
62351
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
62352
        ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62353
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
62354
        HYBRID_BREAK();
62355
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV):
62356
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
62357
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62358
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
62359
        HYBRID_BREAK();
62360
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV):
62361
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
62362
        ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62363
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
62364
        HYBRID_BREAK();
62365
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV):
62366
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
62367
        ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62368
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
62369
        HYBRID_BREAK();
62370
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV):
62371
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
62372
        ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62373
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
62374
        HYBRID_BREAK();
62375
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV):
62376
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
62377
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62378
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
62379
        HYBRID_BREAK();
62380
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV):
62381
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
62382
        ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62383
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
62384
        HYBRID_BREAK();
62385
      HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CV):
62386
        VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
62387
        ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62388
        VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
62389
        HYBRID_BREAK();
62390
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST):
62391
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
62392
        ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62393
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
62394
        HYBRID_BREAK();
62395
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP):
62396
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
62397
        ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62398
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
62399
        HYBRID_BREAK();
62400
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR):
62401
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
62402
        ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62403
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
62404
        HYBRID_BREAK();
62405
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV):
62406
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
62407
        ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62408
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
62409
        HYBRID_BREAK();
62410
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST):
62411
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
62412
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62413
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
62414
        HYBRID_BREAK();
62415
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP):
62416
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
62417
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62418
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
62419
        HYBRID_BREAK();
62420
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR):
62421
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
62422
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62423
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
62424
        HYBRID_BREAK();
62425
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV):
62426
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
62427
        ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62428
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
62429
        HYBRID_BREAK();
62430
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED):
62431
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
62432
        ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62433
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
62434
        HYBRID_BREAK();
62435
      HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED):
62436
        VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
62437
        ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62438
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
62439
        HYBRID_BREAK();
62440
      HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_CV):
62441
        VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_CV)
62442
        ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62443
        VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_CV)
62444
        HYBRID_BREAK();
62445
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR):
62446
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
62447
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62448
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
62449
        HYBRID_BREAK();
62450
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV):
62451
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
62452
        ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62453
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
62454
        HYBRID_BREAK();
62455
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV):
62456
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
62457
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62458
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
62459
        HYBRID_BREAK();
62460
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV):
62461
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
62462
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62463
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
62464
        HYBRID_BREAK();
62465
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CV):
62466
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CV)
62467
        ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62468
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CV)
62469
        HYBRID_BREAK();
62470
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CV):
62471
        VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CV)
62472
        ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62473
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CV)
62474
        HYBRID_BREAK();
62475
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CV):
62476
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CV)
62477
        ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62478
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CV)
62479
        HYBRID_BREAK();
62480
      HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CV):
62481
        VM_TRACE(ZEND_YIELD_SPEC_VAR_CV)
62482
        ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62483
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CV)
62484
        HYBRID_BREAK();
62485
      HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED):
62486
        VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
62487
        ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62488
        VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
62489
        HYBRID_BREAK();
62490
      HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED):
62491
        VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
62492
        ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62493
        VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
62494
        HYBRID_BREAK();
62495
      HYBRID_CASE(ZEND_CLONE_SPEC_UNUSED):
62496
        VM_TRACE(ZEND_CLONE_SPEC_UNUSED)
62497
        ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62498
        VM_TRACE_OP_END(ZEND_CLONE_SPEC_UNUSED)
62499
        HYBRID_BREAK();
62500
      HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED):
62501
        VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
62502
        ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62503
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
62504
        HYBRID_BREAK();
62505
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST):
62506
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
62507
        ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62508
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
62509
        HYBRID_BREAK();
62510
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST):
62511
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
62512
        ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62513
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
62514
        HYBRID_BREAK();
62515
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST):
62516
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
62517
        ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62518
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
62519
        HYBRID_BREAK();
62520
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST):
62521
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
62522
        ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62523
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
62524
        HYBRID_BREAK();
62525
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST):
62526
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
62527
        ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62528
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
62529
        HYBRID_BREAK();
62530
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST):
62531
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
62532
        ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62533
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
62534
        HYBRID_BREAK();
62535
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST):
62536
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
62537
        ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62538
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
62539
        HYBRID_BREAK();
62540
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST):
62541
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
62542
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62543
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
62544
        HYBRID_BREAK();
62545
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST):
62546
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
62547
        ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62548
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
62549
        HYBRID_BREAK();
62550
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST):
62551
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
62552
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62553
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
62554
        HYBRID_BREAK();
62555
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP):
62556
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
62557
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62558
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
62559
        HYBRID_BREAK();
62560
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR):
62561
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
62562
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62563
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
62564
        HYBRID_BREAK();
62565
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV):
62566
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
62567
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62568
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
62569
        HYBRID_BREAK();
62570
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR):
62571
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
62572
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62573
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
62574
        HYBRID_BREAK();
62575
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV):
62576
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
62577
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62578
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
62579
        HYBRID_BREAK();
62580
      HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST):
62581
        VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
62582
        ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62583
        VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
62584
        HYBRID_BREAK();
62585
      HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST):
62586
        VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
62587
        ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62588
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
62589
        HYBRID_BREAK();
62590
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST):
62591
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
62592
        ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62593
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
62594
        HYBRID_BREAK();
62595
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST):
62596
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
62597
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62598
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
62599
        HYBRID_BREAK();
62600
      HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST):
62601
        VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
62602
        ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62603
        VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
62604
        HYBRID_BREAK();
62605
      HYBRID_CASE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST):
62606
        VM_TRACE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
62607
        ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62608
        VM_TRACE_OP_END(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
62609
        HYBRID_BREAK();
62610
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST):
62611
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
62612
        ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62613
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
62614
        HYBRID_BREAK();
62615
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST):
62616
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
62617
        ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62618
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
62619
        HYBRID_BREAK();
62620
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST):
62621
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
62622
        ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62623
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
62624
        HYBRID_BREAK();
62625
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST):
62626
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
62627
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62628
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
62629
        HYBRID_BREAK();
62630
      HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CONST):
62631
        VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CONST)
62632
        ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62633
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CONST)
62634
        HYBRID_BREAK();
62635
      HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV):
62636
        VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
62637
        ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62638
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
62639
        HYBRID_BREAK();
62640
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR):
62641
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
62642
        ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62643
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
62644
        HYBRID_BREAK();
62645
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR):
62646
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
62647
        ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62648
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
62649
        HYBRID_BREAK();
62650
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR):
62651
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
62652
        ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62653
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
62654
        HYBRID_BREAK();
62655
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR):
62656
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
62657
        ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62658
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
62659
        HYBRID_BREAK();
62660
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR):
62661
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
62662
        ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62663
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
62664
        HYBRID_BREAK();
62665
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR):
62666
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
62667
        ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62668
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
62669
        HYBRID_BREAK();
62670
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR):
62671
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
62672
        ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62673
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
62674
        HYBRID_BREAK();
62675
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR):
62676
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
62677
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62678
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
62679
        HYBRID_BREAK();
62680
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR):
62681
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
62682
        ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62683
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
62684
        HYBRID_BREAK();
62685
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST):
62686
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
62687
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62688
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
62689
        HYBRID_BREAK();
62690
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP):
62691
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
62692
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62693
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
62694
        HYBRID_BREAK();
62695
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
62696
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62697
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62698
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62699
        HYBRID_BREAK();
62700
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
62701
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62702
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62703
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62704
        HYBRID_BREAK();
62705
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
62706
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62707
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62708
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62709
        HYBRID_BREAK();
62710
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
62711
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62712
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62713
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62714
        HYBRID_BREAK();
62715
      HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR):
62716
        VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
62717
        ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62718
        VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
62719
        HYBRID_BREAK();
62720
      HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR):
62721
        VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
62722
        ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62723
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
62724
        HYBRID_BREAK();
62725
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR):
62726
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62727
        ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62728
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62729
        HYBRID_BREAK();
62730
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR):
62731
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62732
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62733
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62734
        HYBRID_BREAK();
62735
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR):
62736
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
62737
        ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62738
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
62739
        HYBRID_BREAK();
62740
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR):
62741
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
62742
        ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62743
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
62744
        HYBRID_BREAK();
62745
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR):
62746
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
62747
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62748
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
62749
        HYBRID_BREAK();
62750
      HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_TMPVAR):
62751
        VM_TRACE(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
62752
        ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62753
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
62754
        HYBRID_BREAK();
62755
      HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED):
62756
        VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
62757
        ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62758
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
62759
        HYBRID_BREAK();
62760
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED):
62761
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
62762
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62763
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
62764
        HYBRID_BREAK();
62765
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED):
62766
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
62767
        ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62768
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
62769
        HYBRID_BREAK();
62770
      HYBRID_CASE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED):
62771
        VM_TRACE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
62772
        ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62773
        VM_TRACE_OP_END(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
62774
        HYBRID_BREAK();
62775
      HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED):
62776
        VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
62777
        ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62778
        VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
62779
        HYBRID_BREAK();
62780
      HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK):
62781
        VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
62782
        ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62783
        VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
62784
        HYBRID_BREAK();
62785
      HYBRID_CASE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED):
62786
        VM_TRACE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
62787
        ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62788
        VM_TRACE_OP_END(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
62789
        HYBRID_BREAK();
62790
      HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED):
62791
        VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED)
62792
        ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62793
        VM_TRACE_OP_END(ZEND_NEW_SPEC_UNUSED_UNUSED)
62794
        HYBRID_BREAK();
62795
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED):
62796
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
62797
        ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62798
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
62799
        HYBRID_BREAK();
62800
      HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_UNUSED):
62801
        VM_TRACE(ZEND_YIELD_SPEC_UNUSED_UNUSED)
62802
        ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62803
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_UNUSED)
62804
        HYBRID_BREAK();
62805
      HYBRID_CASE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED):
62806
        VM_TRACE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
62807
        ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62808
        VM_TRACE_OP_END(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
62809
        HYBRID_BREAK();
62810
      HYBRID_CASE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED):
62811
        VM_TRACE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
62812
        ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62813
        VM_TRACE_OP_END(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
62814
        HYBRID_BREAK();
62815
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED):
62816
        VM_TRACE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
62817
        ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62818
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
62819
        HYBRID_BREAK();
62820
      HYBRID_CASE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED):
62821
        VM_TRACE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
62822
        ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62823
        VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
62824
        HYBRID_BREAK();
62825
      HYBRID_CASE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED):
62826
        VM_TRACE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
62827
        ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62828
        VM_TRACE_OP_END(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
62829
        HYBRID_BREAK();
62830
      HYBRID_CASE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED):
62831
        VM_TRACE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
62832
        ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62833
        VM_TRACE_OP_END(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
62834
        HYBRID_BREAK();
62835
      HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED):
62836
        VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
62837
        ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62838
        VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
62839
        HYBRID_BREAK();
62840
      HYBRID_CASE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED):
62841
        VM_TRACE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
62842
        ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62843
        VM_TRACE_OP_END(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
62844
        HYBRID_BREAK();
62845
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED):
62846
        VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
62847
        ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62848
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
62849
        HYBRID_BREAK();
62850
      HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER):
62851
        VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER)
62852
        ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62853
        VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER)
62854
        HYBRID_BREAK();
62855
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV):
62856
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
62857
        ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62858
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
62859
        HYBRID_BREAK();
62860
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV):
62861
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
62862
        ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62863
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
62864
        HYBRID_BREAK();
62865
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV):
62866
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
62867
        ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62868
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
62869
        HYBRID_BREAK();
62870
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV):
62871
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
62872
        ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62873
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
62874
        HYBRID_BREAK();
62875
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV):
62876
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
62877
        ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62878
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
62879
        HYBRID_BREAK();
62880
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV):
62881
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
62882
        ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62883
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
62884
        HYBRID_BREAK();
62885
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV):
62886
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
62887
        ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62888
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
62889
        HYBRID_BREAK();
62890
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV):
62891
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
62892
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62893
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
62894
        HYBRID_BREAK();
62895
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV):
62896
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
62897
        ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62898
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
62899
        HYBRID_BREAK();
62900
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST):
62901
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
62902
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62903
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
62904
        HYBRID_BREAK();
62905
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP):
62906
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
62907
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62908
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
62909
        HYBRID_BREAK();
62910
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR):
62911
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
62912
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62913
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
62914
        HYBRID_BREAK();
62915
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV):
62916
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
62917
        ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62918
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
62919
        HYBRID_BREAK();
62920
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR):
62921
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
62922
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62923
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
62924
        HYBRID_BREAK();
62925
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV):
62926
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
62927
        ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62928
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
62929
        HYBRID_BREAK();
62930
      HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CV):
62931
        VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
62932
        ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62933
        VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
62934
        HYBRID_BREAK();
62935
      HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV):
62936
        VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
62937
        ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62938
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
62939
        HYBRID_BREAK();
62940
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV):
62941
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
62942
        ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62943
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
62944
        HYBRID_BREAK();
62945
      HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV):
62946
        VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
62947
        ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62948
        VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
62949
        HYBRID_BREAK();
62950
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV):
62951
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
62952
        ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62953
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
62954
        HYBRID_BREAK();
62955
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV):
62956
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
62957
        ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62958
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
62959
        HYBRID_BREAK();
62960
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV):
62961
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
62962
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62963
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
62964
        HYBRID_BREAK();
62965
      HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CV):
62966
        VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CV)
62967
        ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62968
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CV)
62969
        HYBRID_BREAK();
62970
      HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CV):
62971
        VM_TRACE(ZEND_BOOL_NOT_SPEC_CV)
62972
        ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62973
        VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CV)
62974
        HYBRID_BREAK();
62975
      HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED):
62976
        VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
62977
        ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62978
        VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
62979
        HYBRID_BREAK();
62980
      HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED):
62981
        VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
62982
        ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62983
        VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
62984
        HYBRID_BREAK();
62985
      HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED):
62986
        VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
62987
        ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62988
        VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
62989
        HYBRID_BREAK();
62990
      HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED):
62991
        VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
62992
        ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62993
        VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
62994
        HYBRID_BREAK();
62995
      HYBRID_CASE(ZEND_POST_INC_SPEC_CV):
62996
        VM_TRACE(ZEND_POST_INC_SPEC_CV)
62997
        ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62998
        VM_TRACE_OP_END(ZEND_POST_INC_SPEC_CV)
62999
        HYBRID_BREAK();
63000
      HYBRID_CASE(ZEND_POST_DEC_SPEC_CV):
63001
        VM_TRACE(ZEND_POST_DEC_SPEC_CV)
63002
        ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63003
        VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_CV)
63004
        HYBRID_BREAK();
63005
      HYBRID_CASE(ZEND_ECHO_SPEC_CV):
63006
        VM_TRACE(ZEND_ECHO_SPEC_CV)
63007
        ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63008
        VM_TRACE_OP_END(ZEND_ECHO_SPEC_CV)
63009
        HYBRID_BREAK();
63010
      HYBRID_CASE(ZEND_JMPZ_SPEC_CV):
63011
        VM_TRACE(ZEND_JMPZ_SPEC_CV)
63012
        ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63013
        VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CV)
63014
        HYBRID_BREAK();
63015
      HYBRID_CASE(ZEND_JMPNZ_SPEC_CV):
63016
        VM_TRACE(ZEND_JMPNZ_SPEC_CV)
63017
        ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63018
        VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CV)
63019
        HYBRID_BREAK();
63020
      HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CV):
63021
        VM_TRACE(ZEND_JMPZ_EX_SPEC_CV)
63022
        ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63023
        VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CV)
63024
        HYBRID_BREAK();
63025
      HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CV):
63026
        VM_TRACE(ZEND_JMPNZ_EX_SPEC_CV)
63027
        ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63028
        VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CV)
63029
        HYBRID_BREAK();
63030
      HYBRID_CASE(ZEND_RETURN_SPEC_CV):
63031
        VM_TRACE(ZEND_RETURN_SPEC_CV)
63032
{
63033
  USE_OPLINE
63034
  zval *retval_ptr;
63035
  zval *return_value;
63036
63037
  retval_ptr = EX_VAR(opline->op1.var);
63038
  return_value = EX(return_value);
63039
63040
  if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
63041
    SAVE_OPLINE();
63042
    retval_ptr = ZVAL_UNDEFINED_OP1();
63043
    if (return_value) {
63044
      ZVAL_NULL(return_value);
63045
    }
63046
  } else if (!return_value) {
63047
    if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
63048
      if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
63049
        SAVE_OPLINE();
63050
        rc_dtor_func(Z_COUNTED_P(retval_ptr));
63051
      }
63052
    }
63053
  } else {
63054
    if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
63055
      ZVAL_COPY_VALUE(return_value, retval_ptr);
63056
      if (IS_CV == IS_CONST) {
63057
        if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
63058
          Z_ADDREF_P(return_value);
63059
        }
63060
      }
63061
    } else if (IS_CV == IS_CV) {
63062
      do {
63063
        if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
63064
          if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
63065
            if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
63066
              zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
63067
              ZVAL_COPY_VALUE(return_value, retval_ptr);
63068
              if (GC_MAY_LEAK(ref)) {
63069
                SAVE_OPLINE();
63070
                gc_possible_root(ref);
63071
              }
63072
              ZVAL_NULL(retval_ptr);
63073
              break;
63074
            } else {
63075
              Z_ADDREF_P(retval_ptr);
63076
            }
63077
          } else {
63078
            retval_ptr = Z_REFVAL_P(retval_ptr);
63079
            if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
63080
              Z_ADDREF_P(retval_ptr);
63081
            }
63082
          }
63083
        }
63084
        ZVAL_COPY_VALUE(return_value, retval_ptr);
63085
      } while (0);
63086
    } else /* if (IS_CV == IS_VAR) */ {
63087
      if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
63088
        zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
63089
63090
        retval_ptr = Z_REFVAL_P(retval_ptr);
63091
        ZVAL_COPY_VALUE(return_value, retval_ptr);
63092
        if (UNEXPECTED(GC_DELREF(ref) == 0)) {
63093
          efree_size(ref, sizeof(zend_reference));
63094
        } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
63095
          Z_ADDREF_P(retval_ptr);
63096
        }
63097
      } else {
63098
        ZVAL_COPY_VALUE(return_value, retval_ptr);
63099
      }
63100
    }
63101
  }
63102
63103
63104
63105
  goto zend_leave_helper_SPEC_LABEL;
63106
}
63107
63108
        VM_TRACE_OP_END(ZEND_RETURN_SPEC_CV)
63109
      HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CV):
63110
        VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV)
63111
        ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63112
        VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CV)
63113
        HYBRID_BREAK();
63114
      HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV):
63115
        VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV)
63116
        ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63117
        VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CV)
63118
        HYBRID_BREAK();
63119
      HYBRID_CASE(ZEND_THROW_SPEC_CV):
63120
        VM_TRACE(ZEND_THROW_SPEC_CV)
63121
        ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63122
        VM_TRACE_OP_END(ZEND_THROW_SPEC_CV)
63123
        HYBRID_BREAK();
63124
      HYBRID_CASE(ZEND_SEND_USER_SPEC_CV):
63125
        VM_TRACE(ZEND_SEND_USER_SPEC_CV)
63126
        ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63127
        VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV)
63128
        HYBRID_BREAK();
63129
      HYBRID_CASE(ZEND_BOOL_SPEC_CV):
63130
        VM_TRACE(ZEND_BOOL_SPEC_CV)
63131
        ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63132
        VM_TRACE_OP_END(ZEND_BOOL_SPEC_CV)
63133
        HYBRID_BREAK();
63134
      HYBRID_CASE(ZEND_CLONE_SPEC_CV):
63135
        VM_TRACE(ZEND_CLONE_SPEC_CV)
63136
        ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63137
        VM_TRACE_OP_END(ZEND_CLONE_SPEC_CV)
63138
        HYBRID_BREAK();
63139
      HYBRID_CASE(ZEND_CAST_SPEC_CV):
63140
        VM_TRACE(ZEND_CAST_SPEC_CV)
63141
        ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63142
        VM_TRACE_OP_END(ZEND_CAST_SPEC_CV)
63143
        HYBRID_BREAK();
63144
      HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV):
63145
        VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
63146
        ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63147
        VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
63148
        HYBRID_BREAK();
63149
      HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CV):
63150
        VM_TRACE(ZEND_FE_RESET_R_SPEC_CV)
63151
        ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63152
        VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CV)
63153
        HYBRID_BREAK();
63154
      HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CV):
63155
        VM_TRACE(ZEND_FE_RESET_RW_SPEC_CV)
63156
        ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63157
        VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CV)
63158
        HYBRID_BREAK();
63159
      HYBRID_CASE(ZEND_JMP_SET_SPEC_CV):
63160
        VM_TRACE(ZEND_JMP_SET_SPEC_CV)
63161
        ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63162
        VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CV)
63163
        HYBRID_BREAK();
63164
      HYBRID_CASE(ZEND_COALESCE_SPEC_CV):
63165
        VM_TRACE(ZEND_COALESCE_SPEC_CV)
63166
        ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63167
        VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CV)
63168
        HYBRID_BREAK();
63169
      HYBRID_CASE(ZEND_JMP_NULL_SPEC_CV):
63170
        VM_TRACE(ZEND_JMP_NULL_SPEC_CV)
63171
        ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63172
        VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CV)
63173
        HYBRID_BREAK();
63174
      HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CV):
63175
        VM_TRACE(ZEND_QM_ASSIGN_SPEC_CV)
63176
        ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63177
        VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CV)
63178
        HYBRID_BREAK();
63179
      HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CV):
63180
        VM_TRACE(ZEND_YIELD_FROM_SPEC_CV)
63181
        ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63182
        VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CV)
63183
        HYBRID_BREAK();
63184
      HYBRID_CASE(ZEND_STRLEN_SPEC_CV):
63185
        VM_TRACE(ZEND_STRLEN_SPEC_CV)
63186
        ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63187
        VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CV)
63188
        HYBRID_BREAK();
63189
      HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CV):
63190
        VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV)
63191
        ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63192
        VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CV)
63193
        HYBRID_BREAK();
63194
      HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_CV):
63195
        VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_CV)
63196
        ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63197
        VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_CV)
63198
        HYBRID_BREAK();
63199
      HYBRID_CASE(ZEND_BIND_STATIC_SPEC_CV):
63200
        VM_TRACE(ZEND_BIND_STATIC_SPEC_CV)
63201
        ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63202
        VM_TRACE_OP_END(ZEND_BIND_STATIC_SPEC_CV)
63203
        HYBRID_BREAK();
63204
      HYBRID_CASE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV):
63205
        VM_TRACE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
63206
        ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63207
        VM_TRACE_OP_END(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
63208
        HYBRID_BREAK();
63209
      HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
63210
        VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63211
        ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63212
        VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63213
        HYBRID_BREAK();
63214
      HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
63215
        VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63216
        ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63217
        VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63218
        HYBRID_BREAK();
63219
      HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED):
63220
        VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
63221
        ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63222
        VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
63223
        HYBRID_BREAK();
63224
      HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED):
63225
        VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
63226
        ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63227
        VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
63228
        HYBRID_BREAK();
63229
      HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
63230
        VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63231
        ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63232
        VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63233
        HYBRID_BREAK();
63234
      HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
63235
        VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63236
        ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63237
        VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63238
        HYBRID_BREAK();
63239
      HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED):
63240
        VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
63241
        ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63242
        VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
63243
        HYBRID_BREAK();
63244
      HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED):
63245
        VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
63246
        ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63247
        VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
63248
        HYBRID_BREAK();
63249
      HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV):
63250
        VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
63251
        ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63252
        VM_TRACE_OP_END(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
63253
        HYBRID_BREAK();
63254
      HYBRID_CASE(ZEND_POST_INC_LONG_SPEC_CV):
63255
        VM_TRACE(ZEND_POST_INC_LONG_SPEC_CV)
63256
        ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63257
        VM_TRACE_OP_END(ZEND_POST_INC_LONG_SPEC_CV)
63258
        HYBRID_BREAK();
63259
      HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV):
63260
        VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
63261
        ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63262
        VM_TRACE_OP_END(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
63263
        HYBRID_BREAK();
63264
      HYBRID_CASE(ZEND_POST_DEC_LONG_SPEC_CV):
63265
        VM_TRACE(ZEND_POST_DEC_LONG_SPEC_CV)
63266
        ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63267
        VM_TRACE_OP_END(ZEND_POST_DEC_LONG_SPEC_CV)
63268
        HYBRID_BREAK();
63269
      HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_CV):
63270
        VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
63271
        ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63272
        VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
63273
        HYBRID_BREAK();
63274
      HYBRID_CASE(ZEND_DIV_SPEC_CV_CONST):
63275
        VM_TRACE(ZEND_DIV_SPEC_CV_CONST)
63276
        ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63277
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CONST)
63278
        HYBRID_BREAK();
63279
      HYBRID_CASE(ZEND_POW_SPEC_CV_CONST):
63280
        VM_TRACE(ZEND_POW_SPEC_CV_CONST)
63281
        ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63282
        VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CONST)
63283
        HYBRID_BREAK();
63284
      HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CONST):
63285
        VM_TRACE(ZEND_CONCAT_SPEC_CV_CONST)
63286
        ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63287
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CONST)
63288
        HYBRID_BREAK();
63289
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CONST):
63290
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
63291
        ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63292
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
63293
        HYBRID_BREAK();
63294
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST):
63295
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
63296
        ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63297
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
63298
        HYBRID_BREAK();
63299
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST):
63300
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST)
63301
        ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63302
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST)
63303
        HYBRID_BREAK();
63304
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ):
63305
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
63306
        ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63307
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
63308
        HYBRID_BREAK();
63309
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ):
63310
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
63311
        ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63312
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
63313
        HYBRID_BREAK();
63314
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST):
63315
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
63316
        ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63317
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
63318
        HYBRID_BREAK();
63319
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ):
63320
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
63321
        ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63322
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
63323
        HYBRID_BREAK();
63324
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ):
63325
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
63326
        ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63327
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
63328
        HYBRID_BREAK();
63329
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CONST):
63330
        VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CONST)
63331
        ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63332
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CONST)
63333
        HYBRID_BREAK();
63334
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CONST):
63335
        VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CONST)
63336
        ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63337
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CONST)
63338
        HYBRID_BREAK();
63339
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST):
63340
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
63341
        ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63342
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
63343
        HYBRID_BREAK();
63344
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST):
63345
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
63346
        ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63347
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
63348
        HYBRID_BREAK();
63349
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CONST):
63350
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CONST)
63351
        ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63352
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CONST)
63353
        HYBRID_BREAK();
63354
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST):
63355
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
63356
        ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63357
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
63358
        HYBRID_BREAK();
63359
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CONST):
63360
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
63361
        ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63362
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
63363
        HYBRID_BREAK();
63364
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CONST):
63365
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
63366
        ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63367
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
63368
        HYBRID_BREAK();
63369
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CONST):
63370
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
63371
        ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63372
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
63373
        HYBRID_BREAK();
63374
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST):
63375
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
63376
        ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63377
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
63378
        HYBRID_BREAK();
63379
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST):
63380
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
63381
        ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63382
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
63383
        HYBRID_BREAK();
63384
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST):
63385
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
63386
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63387
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
63388
        HYBRID_BREAK();
63389
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST):
63390
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
63391
        ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63392
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
63393
        HYBRID_BREAK();
63394
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST):
63395
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
63396
        ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63397
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
63398
        HYBRID_BREAK();
63399
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST):
63400
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
63401
        ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63402
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
63403
        HYBRID_BREAK();
63404
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST):
63405
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
63406
        ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63407
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
63408
        HYBRID_BREAK();
63409
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST):
63410
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
63411
        ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63412
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
63413
        HYBRID_BREAK();
63414
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST):
63415
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
63416
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63417
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
63418
        HYBRID_BREAK();
63419
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST):
63420
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
63421
        ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63422
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
63423
        HYBRID_BREAK();
63424
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST):
63425
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
63426
        ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63427
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
63428
        HYBRID_BREAK();
63429
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP):
63430
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
63431
        ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63432
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
63433
        HYBRID_BREAK();
63434
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR):
63435
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
63436
        ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63437
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
63438
        HYBRID_BREAK();
63439
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV):
63440
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
63441
        ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63442
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
63443
        HYBRID_BREAK();
63444
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST):
63445
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
63446
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63447
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
63448
        HYBRID_BREAK();
63449
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP):
63450
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
63451
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63452
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
63453
        HYBRID_BREAK();
63454
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR):
63455
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
63456
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63457
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
63458
        HYBRID_BREAK();
63459
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV):
63460
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
63461
        ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63462
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
63463
        HYBRID_BREAK();
63464
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED):
63465
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
63466
        ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63467
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
63468
        HYBRID_BREAK();
63469
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED):
63470
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
63471
        ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63472
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
63473
        HYBRID_BREAK();
63474
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR):
63475
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
63476
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63477
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
63478
        HYBRID_BREAK();
63479
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV):
63480
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
63481
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63482
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
63483
        HYBRID_BREAK();
63484
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CONST):
63485
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CONST)
63486
        ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63487
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CONST)
63488
        HYBRID_BREAK();
63489
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST):
63490
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
63491
        ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63492
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
63493
        HYBRID_BREAK();
63494
      HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST):
63495
        VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST)
63496
        ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63497
        VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_CONST)
63498
        HYBRID_BREAK();
63499
      HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_CONST):
63500
        VM_TRACE(ZEND_SEND_REF_SPEC_CV_CONST)
63501
        ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63502
        VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_CONST)
63503
        HYBRID_BREAK();
63504
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_CONST):
63505
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
63506
        ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63507
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
63508
        HYBRID_BREAK();
63509
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST):
63510
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
63511
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63512
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
63513
        HYBRID_BREAK();
63514
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CONST):
63515
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CONST)
63516
        ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63517
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CONST)
63518
        HYBRID_BREAK();
63519
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CONST):
63520
        VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CONST)
63521
        ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63522
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CONST)
63523
        HYBRID_BREAK();
63524
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CONST):
63525
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CONST)
63526
        ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63527
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CONST)
63528
        HYBRID_BREAK();
63529
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST):
63530
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
63531
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63532
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
63533
        HYBRID_BREAK();
63534
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST):
63535
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
63536
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63537
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
63538
        HYBRID_BREAK();
63539
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST):
63540
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
63541
        ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63542
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
63543
        HYBRID_BREAK();
63544
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_CONST):
63545
        VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_CONST)
63546
        ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63547
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_CONST)
63548
        HYBRID_BREAK();
63549
      HYBRID_CASE(ZEND_YIELD_SPEC_CV_CONST):
63550
        VM_TRACE(ZEND_YIELD_SPEC_CV_CONST)
63551
        ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63552
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CONST)
63553
        HYBRID_BREAK();
63554
      HYBRID_CASE(ZEND_BIND_GLOBAL_SPEC_CV_CONST):
63555
        VM_TRACE(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
63556
        ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63557
        VM_TRACE_OP_END(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
63558
        HYBRID_BREAK();
63559
      HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CV_CONST):
63560
        VM_TRACE(ZEND_IN_ARRAY_SPEC_CV_CONST)
63561
        ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63562
        VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CV_CONST)
63563
        HYBRID_BREAK();
63564
      HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST):
63565
        VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63566
        ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63567
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63568
        HYBRID_BREAK();
63569
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST):
63570
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63571
        ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63572
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63573
        HYBRID_BREAK();
63574
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST):
63575
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
63576
        ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63577
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
63578
        HYBRID_BREAK();
63579
      HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV):
63580
        VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
63581
        ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63582
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
63583
        HYBRID_BREAK();
63584
      HYBRID_CASE(ZEND_DIV_SPEC_CV_TMPVAR):
63585
        VM_TRACE(ZEND_DIV_SPEC_CV_TMPVAR)
63586
        ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63587
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_TMPVAR)
63588
        HYBRID_BREAK();
63589
      HYBRID_CASE(ZEND_POW_SPEC_CV_TMPVAR):
63590
        VM_TRACE(ZEND_POW_SPEC_CV_TMPVAR)
63591
        ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63592
        VM_TRACE_OP_END(ZEND_POW_SPEC_CV_TMPVAR)
63593
        HYBRID_BREAK();
63594
      HYBRID_CASE(ZEND_CONCAT_SPEC_CV_TMPVAR):
63595
        VM_TRACE(ZEND_CONCAT_SPEC_CV_TMPVAR)
63596
        ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63597
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_TMPVAR)
63598
        HYBRID_BREAK();
63599
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR):
63600
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
63601
        ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63602
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
63603
        HYBRID_BREAK();
63604
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ):
63605
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63606
        ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63607
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63608
        HYBRID_BREAK();
63609
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
63610
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63611
        ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63612
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63613
        HYBRID_BREAK();
63614
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR):
63615
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
63616
        ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63617
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
63618
        HYBRID_BREAK();
63619
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ):
63620
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63621
        ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63622
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63623
        HYBRID_BREAK();
63624
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
63625
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63626
        ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63627
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63628
        HYBRID_BREAK();
63629
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMPVAR):
63630
        VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
63631
        ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63632
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
63633
        HYBRID_BREAK();
63634
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR):
63635
        VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
63636
        ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63637
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
63638
        HYBRID_BREAK();
63639
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR):
63640
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
63641
        ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63642
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
63643
        HYBRID_BREAK();
63644
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR):
63645
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
63646
        ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63647
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
63648
        HYBRID_BREAK();
63649
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR):
63650
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
63651
        ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63652
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
63653
        HYBRID_BREAK();
63654
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR):
63655
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
63656
        ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63657
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
63658
        HYBRID_BREAK();
63659
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR):
63660
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
63661
        ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63662
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
63663
        HYBRID_BREAK();
63664
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR):
63665
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
63666
        ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63667
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
63668
        HYBRID_BREAK();
63669
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR):
63670
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
63671
        ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63672
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
63673
        HYBRID_BREAK();
63674
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR):
63675
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
63676
        ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63677
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
63678
        HYBRID_BREAK();
63679
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR):
63680
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
63681
        ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63682
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
63683
        HYBRID_BREAK();
63684
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR):
63685
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
63686
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63687
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
63688
        HYBRID_BREAK();
63689
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR):
63690
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
63691
        ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63692
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
63693
        HYBRID_BREAK();
63694
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR):
63695
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
63696
        ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63697
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
63698
        HYBRID_BREAK();
63699
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR):
63700
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
63701
        ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63702
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
63703
        HYBRID_BREAK();
63704
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR):
63705
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
63706
        ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63707
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
63708
        HYBRID_BREAK();
63709
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR):
63710
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
63711
        ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63712
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
63713
        HYBRID_BREAK();
63714
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR):
63715
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
63716
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63717
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
63718
        HYBRID_BREAK();
63719
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR):
63720
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
63721
        ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63722
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
63723
        HYBRID_BREAK();
63724
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST):
63725
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
63726
        ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63727
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
63728
        HYBRID_BREAK();
63729
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP):
63730
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
63731
        ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63732
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
63733
        HYBRID_BREAK();
63734
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR):
63735
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
63736
        ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63737
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
63738
        HYBRID_BREAK();
63739
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV):
63740
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
63741
        ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63742
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
63743
        HYBRID_BREAK();
63744
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST):
63745
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
63746
        ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63747
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
63748
        HYBRID_BREAK();
63749
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP):
63750
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
63751
        ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63752
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
63753
        HYBRID_BREAK();
63754
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR):
63755
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
63756
        ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63757
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
63758
        HYBRID_BREAK();
63759
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV):
63760
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
63761
        ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63762
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
63763
        HYBRID_BREAK();
63764
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR):
63765
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
63766
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63767
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
63768
        HYBRID_BREAK();
63769
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV):
63770
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
63771
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63772
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
63773
        HYBRID_BREAK();
63774
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR):
63775
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
63776
        ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63777
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
63778
        HYBRID_BREAK();
63779
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR):
63780
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
63781
        ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63782
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
63783
        HYBRID_BREAK();
63784
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR):
63785
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
63786
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63787
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
63788
        HYBRID_BREAK();
63789
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR):
63790
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
63791
        ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63792
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
63793
        HYBRID_BREAK();
63794
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR):
63795
        VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
63796
        ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63797
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
63798
        HYBRID_BREAK();
63799
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR):
63800
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
63801
        ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63802
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
63803
        HYBRID_BREAK();
63804
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR):
63805
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
63806
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63807
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
63808
        HYBRID_BREAK();
63809
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR):
63810
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
63811
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63812
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
63813
        HYBRID_BREAK();
63814
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR):
63815
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
63816
        ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63817
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
63818
        HYBRID_BREAK();
63819
      HYBRID_CASE(ZEND_YIELD_SPEC_CV_TMPVAR):
63820
        VM_TRACE(ZEND_YIELD_SPEC_CV_TMPVAR)
63821
        ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63822
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMPVAR)
63823
        HYBRID_BREAK();
63824
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_TMP):
63825
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
63826
        ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63827
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
63828
        HYBRID_BREAK();
63829
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP):
63830
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
63831
        ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63832
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
63833
        HYBRID_BREAK();
63834
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED):
63835
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
63836
        ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63837
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
63838
        HYBRID_BREAK();
63839
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED):
63840
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
63841
        ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63842
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
63843
        HYBRID_BREAK();
63844
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_VAR):
63845
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
63846
        ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63847
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
63848
        HYBRID_BREAK();
63849
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR):
63850
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
63851
        ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63852
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
63853
        HYBRID_BREAK();
63854
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED):
63855
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
63856
        ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63857
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
63858
        HYBRID_BREAK();
63859
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED):
63860
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
63861
        ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63862
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
63863
        HYBRID_BREAK();
63864
      HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_VAR):
63865
        VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR)
63866
        ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63867
        VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_VAR)
63868
        HYBRID_BREAK();
63869
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_VAR):
63870
        VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_VAR)
63871
        ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63872
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_VAR)
63873
        HYBRID_BREAK();
63874
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED):
63875
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
63876
        ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63877
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
63878
        HYBRID_BREAK();
63879
      HYBRID_CASE(ZEND_FETCH_R_SPEC_CV_UNUSED):
63880
        VM_TRACE(ZEND_FETCH_R_SPEC_CV_UNUSED)
63881
        ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63882
        VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CV_UNUSED)
63883
        HYBRID_BREAK();
63884
      HYBRID_CASE(ZEND_FETCH_W_SPEC_CV_UNUSED):
63885
        VM_TRACE(ZEND_FETCH_W_SPEC_CV_UNUSED)
63886
        ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63887
        VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CV_UNUSED)
63888
        HYBRID_BREAK();
63889
      HYBRID_CASE(ZEND_FETCH_RW_SPEC_CV_UNUSED):
63890
        VM_TRACE(ZEND_FETCH_RW_SPEC_CV_UNUSED)
63891
        ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63892
        VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CV_UNUSED)
63893
        HYBRID_BREAK();
63894
      HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED):
63895
        VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
63896
        ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63897
        VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
63898
        HYBRID_BREAK();
63899
      HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED):
63900
        VM_TRACE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
63901
        ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63902
        VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
63903
        HYBRID_BREAK();
63904
      HYBRID_CASE(ZEND_FETCH_IS_SPEC_CV_UNUSED):
63905
        VM_TRACE(ZEND_FETCH_IS_SPEC_CV_UNUSED)
63906
        ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63907
        VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CV_UNUSED)
63908
        HYBRID_BREAK();
63909
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED):
63910
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
63911
        ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63912
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
63913
        HYBRID_BREAK();
63914
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED):
63915
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
63916
        ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63917
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
63918
        HYBRID_BREAK();
63919
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED):
63920
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
63921
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63922
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
63923
        HYBRID_BREAK();
63924
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST):
63925
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
63926
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63927
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
63928
        HYBRID_BREAK();
63929
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP):
63930
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
63931
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63932
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
63933
        HYBRID_BREAK();
63934
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR):
63935
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
63936
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63937
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
63938
        HYBRID_BREAK();
63939
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV):
63940
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
63941
        ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63942
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
63943
        HYBRID_BREAK();
63944
      HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED):
63945
        VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
63946
        ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63947
        VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
63948
        HYBRID_BREAK();
63949
      HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_UNUSED):
63950
        VM_TRACE(ZEND_SEND_VAR_SPEC_CV_UNUSED)
63951
        ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63952
        VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_UNUSED)
63953
        HYBRID_BREAK();
63954
      HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_UNUSED):
63955
        VM_TRACE(ZEND_SEND_REF_SPEC_CV_UNUSED)
63956
        ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63957
        VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_UNUSED)
63958
        HYBRID_BREAK();
63959
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED):
63960
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
63961
        ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63962
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
63963
        HYBRID_BREAK();
63964
      HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK):
63965
        VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
63966
        ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63967
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
63968
        HYBRID_BREAK();
63969
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED):
63970
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
63971
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63972
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
63973
        HYBRID_BREAK();
63974
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED):
63975
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
63976
        ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63977
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
63978
        HYBRID_BREAK();
63979
      HYBRID_CASE(ZEND_UNSET_CV_SPEC_CV_UNUSED):
63980
        VM_TRACE(ZEND_UNSET_CV_SPEC_CV_UNUSED)
63981
        ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63982
        VM_TRACE_OP_END(ZEND_UNSET_CV_SPEC_CV_UNUSED)
63983
        HYBRID_BREAK();
63984
      HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CV_UNUSED):
63985
        VM_TRACE(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
63986
        ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63987
        VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
63988
        HYBRID_BREAK();
63989
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET):
63990
        VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
63991
        ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63992
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
63993
        HYBRID_BREAK();
63994
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY):
63995
        VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
63996
        ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63997
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
63998
        HYBRID_BREAK();
63999
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED):
64000
        VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
64001
        ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64002
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
64003
        HYBRID_BREAK();
64004
      HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_UNUSED):
64005
        VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
64006
        ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64007
        VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
64008
        HYBRID_BREAK();
64009
      HYBRID_CASE(ZEND_YIELD_SPEC_CV_UNUSED):
64010
        VM_TRACE(ZEND_YIELD_SPEC_CV_UNUSED)
64011
        ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64012
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_UNUSED)
64013
        HYBRID_BREAK();
64014
      HYBRID_CASE(ZEND_CHECK_VAR_SPEC_CV_UNUSED):
64015
        VM_TRACE(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
64016
        ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64017
        VM_TRACE_OP_END(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
64018
        HYBRID_BREAK();
64019
      HYBRID_CASE(ZEND_MAKE_REF_SPEC_CV_UNUSED):
64020
        VM_TRACE(ZEND_MAKE_REF_SPEC_CV_UNUSED)
64021
        ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64022
        VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_CV_UNUSED)
64023
        HYBRID_BREAK();
64024
      HYBRID_CASE(ZEND_COUNT_SPEC_CV_UNUSED):
64025
        VM_TRACE(ZEND_COUNT_SPEC_CV_UNUSED)
64026
        ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64027
        VM_TRACE_OP_END(ZEND_COUNT_SPEC_CV_UNUSED)
64028
        HYBRID_BREAK();
64029
      HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED):
64030
        VM_TRACE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
64031
        ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64032
        VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
64033
        HYBRID_BREAK();
64034
      HYBRID_CASE(ZEND_GET_CLASS_SPEC_CV_UNUSED):
64035
        VM_TRACE(ZEND_GET_CLASS_SPEC_CV_UNUSED)
64036
        ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64037
        VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CV_UNUSED)
64038
        HYBRID_BREAK();
64039
      HYBRID_CASE(ZEND_GET_TYPE_SPEC_CV_UNUSED):
64040
        VM_TRACE(ZEND_GET_TYPE_SPEC_CV_UNUSED)
64041
        ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64042
        VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CV_UNUSED)
64043
        HYBRID_BREAK();
64044
      HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED):
64045
        VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
64046
        ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64047
        VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
64048
        HYBRID_BREAK();
64049
      HYBRID_CASE(ZEND_DIV_SPEC_CV_CV):
64050
        VM_TRACE(ZEND_DIV_SPEC_CV_CV)
64051
        ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64052
        VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CV)
64053
        HYBRID_BREAK();
64054
      HYBRID_CASE(ZEND_POW_SPEC_CV_CV):
64055
        VM_TRACE(ZEND_POW_SPEC_CV_CV)
64056
        ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64057
        VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CV)
64058
        HYBRID_BREAK();
64059
      HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CV):
64060
        VM_TRACE(ZEND_CONCAT_SPEC_CV_CV)
64061
        ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64062
        VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CV)
64063
        HYBRID_BREAK();
64064
      HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CV):
64065
        VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CV)
64066
        ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64067
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CV)
64068
        HYBRID_BREAK();
64069
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV):
64070
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
64071
        ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64072
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
64073
        HYBRID_BREAK();
64074
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV):
64075
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV)
64076
        ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64077
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV)
64078
        HYBRID_BREAK();
64079
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ):
64080
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
64081
        ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64082
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
64083
        HYBRID_BREAK();
64084
      HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ):
64085
        VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
64086
        ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64087
        VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
64088
        HYBRID_BREAK();
64089
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV):
64090
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
64091
        ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64092
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
64093
        HYBRID_BREAK();
64094
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ):
64095
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
64096
        ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64097
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
64098
        HYBRID_BREAK();
64099
      HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ):
64100
        VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
64101
        ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64102
        VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
64103
        HYBRID_BREAK();
64104
      HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CV):
64105
        VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CV)
64106
        ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64107
        VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CV)
64108
        HYBRID_BREAK();
64109
      HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CV):
64110
        VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CV)
64111
        ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64112
        VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CV)
64113
        HYBRID_BREAK();
64114
      HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV):
64115
        VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
64116
        ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64117
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
64118
        HYBRID_BREAK();
64119
      HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV):
64120
        VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
64121
        ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64122
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
64123
        HYBRID_BREAK();
64124
      HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CV):
64125
        VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CV)
64126
        ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64127
        VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CV)
64128
        HYBRID_BREAK();
64129
      HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CV):
64130
        VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
64131
        ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64132
        VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
64133
        HYBRID_BREAK();
64134
      HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CV):
64135
        VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CV)
64136
        ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64137
        VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CV)
64138
        HYBRID_BREAK();
64139
      HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CV):
64140
        VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CV)
64141
        ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64142
        VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CV)
64143
        HYBRID_BREAK();
64144
      HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CV):
64145
        VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CV)
64146
        ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64147
        VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CV)
64148
        HYBRID_BREAK();
64149
      HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CV):
64150
        VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
64151
        ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64152
        VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
64153
        HYBRID_BREAK();
64154
      HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CV):
64155
        VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
64156
        ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64157
        VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
64158
        HYBRID_BREAK();
64159
      HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV):
64160
        VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
64161
        ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64162
        VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
64163
        HYBRID_BREAK();
64164
      HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV):
64165
        VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
64166
        ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64167
        VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
64168
        HYBRID_BREAK();
64169
      HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CV):
64170
        VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
64171
        ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64172
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
64173
        HYBRID_BREAK();
64174
      HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CV):
64175
        VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
64176
        ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64177
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
64178
        HYBRID_BREAK();
64179
      HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV):
64180
        VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
64181
        ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64182
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
64183
        HYBRID_BREAK();
64184
      HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV):
64185
        VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
64186
        ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64187
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
64188
        HYBRID_BREAK();
64189
      HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV):
64190
        VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
64191
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64192
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
64193
        HYBRID_BREAK();
64194
      HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV):
64195
        VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
64196
        ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64197
        VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
64198
        HYBRID_BREAK();
64199
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST):
64200
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
64201
        ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64202
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
64203
        HYBRID_BREAK();
64204
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP):
64205
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
64206
        ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64207
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
64208
        HYBRID_BREAK();
64209
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR):
64210
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
64211
        ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64212
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
64213
        HYBRID_BREAK();
64214
      HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV):
64215
        VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
64216
        ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64217
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
64218
        HYBRID_BREAK();
64219
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST):
64220
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
64221
        ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64222
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
64223
        HYBRID_BREAK();
64224
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP):
64225
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
64226
        ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64227
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
64228
        HYBRID_BREAK();
64229
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR):
64230
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
64231
        ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64232
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
64233
        HYBRID_BREAK();
64234
      HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV):
64235
        VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
64236
        ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64237
        VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
64238
        HYBRID_BREAK();
64239
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED):
64240
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
64241
        ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64242
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
64243
        HYBRID_BREAK();
64244
      HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED):
64245
        VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
64246
        ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64247
        VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
64248
        HYBRID_BREAK();
64249
      HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_CV):
64250
        VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV)
64251
        ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64252
        VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_CV)
64253
        HYBRID_BREAK();
64254
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR):
64255
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
64256
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64257
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
64258
        HYBRID_BREAK();
64259
      HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV):
64260
        VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
64261
        ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64262
        VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
64263
        HYBRID_BREAK();
64264
      HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CV):
64265
        VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CV)
64266
        ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64267
        VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CV)
64268
        HYBRID_BREAK();
64269
      HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV):
64270
        VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
64271
        ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64272
        VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
64273
        HYBRID_BREAK();
64274
      HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV):
64275
        VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
64276
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64277
        VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
64278
        HYBRID_BREAK();
64279
      HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CV):
64280
        VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CV)
64281
        ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64282
        VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CV)
64283
        HYBRID_BREAK();
64284
      HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CV):
64285
        VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CV)
64286
        ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64287
        VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CV)
64288
        HYBRID_BREAK();
64289
      HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CV):
64290
        VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CV)
64291
        ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64292
        VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CV)
64293
        HYBRID_BREAK();
64294
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV):
64295
        VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
64296
        ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64297
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
64298
        HYBRID_BREAK();
64299
      HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV):
64300
        VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
64301
        ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64302
        VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
64303
        HYBRID_BREAK();
64304
      HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV):
64305
        VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
64306
        ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64307
        VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
64308
        HYBRID_BREAK();
64309
      HYBRID_CASE(ZEND_YIELD_SPEC_CV_CV):
64310
        VM_TRACE(ZEND_YIELD_SPEC_CV_CV)
64311
        ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64312
        VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CV)
64313
        HYBRID_BREAK();
64314
      HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV):
64315
        VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
64316
        ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64317
        VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
64318
        HYBRID_BREAK();
64319
      HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV):
64320
        VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
64321
        ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64322
        VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
64323
        HYBRID_BREAK();
64324
      HYBRID_CASE(HYBRID_HALT):
64325
#ifdef ZEND_VM_FP_GLOBAL_REG
64326
        execute_data = vm_stack_data.orig_execute_data;
64327
#endif
64328
#ifdef ZEND_VM_IP_GLOBAL_REG
64329
        opline = vm_stack_data.orig_opline;
64330
#endif
64331
        return;
64332
      HYBRID_DEFAULT:
64333
        VM_TRACE(ZEND_NULL)
64334
        ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64335
        VM_TRACE_OP_END(ZEND_NULL)
64336
        HYBRID_BREAK(); /* Never reached */
64337
#else /* ZEND_VM_KIND != ZEND_VM_KIND_HYBRID */
64338
#ifdef ZEND_VM_FP_GLOBAL_REG
64339
      execute_data = vm_stack_data.orig_execute_data;
64340
# ifdef ZEND_VM_IP_GLOBAL_REG
64341
      opline = vm_stack_data.orig_opline;
64342
# endif
64343
      return;
64344
#else
64345
113k
      opline = (const zend_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT);
64346
113k
      if (EXPECTED(opline != NULL)) {
64347
59.6k
        execute_data = EG(current_execute_data);
64348
59.6k
        ZEND_VM_LOOP_INTERRUPT_CHECK();
64349
59.6k
      } else {
64350
# ifdef ZEND_VM_IP_GLOBAL_REG
64351
        opline = vm_stack_data.orig_opline;
64352
# endif
64353
53.3k
        return;
64354
53.3k
      }
64355
113k
#endif
64356
113k
#endif /* ZEND_VM_KIND != ZEND_VM_KIND_HYBRID */
64357
113k
    }
64358
64359
3.61M
  }
64360
29.2k
  zend_error_noreturn(E_CORE_ERROR, "Arrived at end of main loop which shouldn't happen");
64361
82.6k
}
64362
#if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
64363
# pragma GCC pop_options
64364
#endif
64365
64366
ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
64367
86.9k
{
64368
86.9k
  zend_execute_data *execute_data;
64369
86.9k
  void *object_or_called_scope;
64370
86.9k
  uint32_t call_info;
64371
64372
86.9k
  if (EG(exception) != NULL) {
64373
0
    return;
64374
0
  }
64375
64376
86.9k
  object_or_called_scope = zend_get_this_object(EG(current_execute_data));
64377
86.9k
  if (EXPECTED(!object_or_called_scope)) {
64378
86.9k
    object_or_called_scope = zend_get_called_scope(EG(current_execute_data));
64379
86.9k
    call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE;
64380
86.9k
  } else {
64381
0
    call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE | ZEND_CALL_HAS_THIS;
64382
0
  }
64383
86.9k
  execute_data = zend_vm_stack_push_call_frame(call_info,
64384
86.9k
    (zend_function*)op_array, 0, object_or_called_scope);
64385
86.9k
  if (EG(current_execute_data)) {
64386
0
    execute_data->symbol_table = zend_rebuild_symbol_table();
64387
86.9k
  } else {
64388
86.9k
    execute_data->symbol_table = &EG(symbol_table);
64389
86.9k
  }
64390
86.9k
  EX(prev_execute_data) = EG(current_execute_data);
64391
86.9k
  i_init_code_execute_data(execute_data, op_array, return_value);
64392
86.9k
  ZEND_OBSERVER_FCALL_BEGIN(execute_data);
64393
86.9k
  zend_execute_ex(execute_data);
64394
  /* Observer end handlers are called from ZEND_RETURN */
64395
86.9k
  zend_vm_stack_free_call_frame(execute_data);
64396
86.9k
}
64397
64398
64399
void zend_vm_init(void)
64400
16
{
64401
16
  static const void * const labels[] = {
64402
16
    ZEND_NOP_SPEC_HANDLER,
64403
16
    ZEND_ADD_SPEC_CONST_CONST_HANDLER,
64404
16
    ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64405
16
    ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64406
16
    ZEND_NULL_HANDLER,
64407
16
    ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64408
16
    ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64409
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64410
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64411
16
    ZEND_NULL_HANDLER,
64412
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64413
16
    ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64414
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64415
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64416
16
    ZEND_NULL_HANDLER,
64417
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64418
16
    ZEND_NULL_HANDLER,
64419
16
    ZEND_NULL_HANDLER,
64420
16
    ZEND_NULL_HANDLER,
64421
16
    ZEND_NULL_HANDLER,
64422
16
    ZEND_NULL_HANDLER,
64423
16
    ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64424
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64425
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64426
16
    ZEND_NULL_HANDLER,
64427
16
    ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64428
16
    ZEND_SUB_SPEC_CONST_CONST_HANDLER,
64429
16
    ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64430
16
    ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64431
16
    ZEND_NULL_HANDLER,
64432
16
    ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64433
16
    ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64434
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64435
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64436
16
    ZEND_NULL_HANDLER,
64437
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64438
16
    ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64439
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64440
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64441
16
    ZEND_NULL_HANDLER,
64442
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64443
16
    ZEND_NULL_HANDLER,
64444
16
    ZEND_NULL_HANDLER,
64445
16
    ZEND_NULL_HANDLER,
64446
16
    ZEND_NULL_HANDLER,
64447
16
    ZEND_NULL_HANDLER,
64448
16
    ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64449
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64450
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64451
16
    ZEND_NULL_HANDLER,
64452
16
    ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64453
16
    ZEND_MUL_SPEC_CONST_CONST_HANDLER,
64454
16
    ZEND_NULL_HANDLER,
64455
16
    ZEND_NULL_HANDLER,
64456
16
    ZEND_NULL_HANDLER,
64457
16
    ZEND_NULL_HANDLER,
64458
16
    ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64459
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64460
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64461
16
    ZEND_NULL_HANDLER,
64462
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64463
16
    ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64464
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64465
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64466
16
    ZEND_NULL_HANDLER,
64467
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64468
16
    ZEND_NULL_HANDLER,
64469
16
    ZEND_NULL_HANDLER,
64470
16
    ZEND_NULL_HANDLER,
64471
16
    ZEND_NULL_HANDLER,
64472
16
    ZEND_NULL_HANDLER,
64473
16
    ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64474
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64475
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64476
16
    ZEND_NULL_HANDLER,
64477
16
    ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64478
16
    ZEND_DIV_SPEC_CONST_CONST_HANDLER,
64479
16
    ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
64480
16
    ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
64481
16
    ZEND_NULL_HANDLER,
64482
16
    ZEND_DIV_SPEC_CONST_CV_HANDLER,
64483
16
    ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
64484
16
    ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64485
16
    ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64486
16
    ZEND_NULL_HANDLER,
64487
16
    ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
64488
16
    ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
64489
16
    ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64490
16
    ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64491
16
    ZEND_NULL_HANDLER,
64492
16
    ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
64493
16
    ZEND_NULL_HANDLER,
64494
16
    ZEND_NULL_HANDLER,
64495
16
    ZEND_NULL_HANDLER,
64496
16
    ZEND_NULL_HANDLER,
64497
16
    ZEND_NULL_HANDLER,
64498
16
    ZEND_DIV_SPEC_CV_CONST_HANDLER,
64499
16
    ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
64500
16
    ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
64501
16
    ZEND_NULL_HANDLER,
64502
16
    ZEND_DIV_SPEC_CV_CV_HANDLER,
64503
16
    ZEND_MOD_SPEC_CONST_CONST_HANDLER,
64504
16
    ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64505
16
    ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64506
16
    ZEND_NULL_HANDLER,
64507
16
    ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64508
16
    ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64509
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64510
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64511
16
    ZEND_NULL_HANDLER,
64512
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64513
16
    ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64514
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64515
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64516
16
    ZEND_NULL_HANDLER,
64517
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64518
16
    ZEND_NULL_HANDLER,
64519
16
    ZEND_NULL_HANDLER,
64520
16
    ZEND_NULL_HANDLER,
64521
16
    ZEND_NULL_HANDLER,
64522
16
    ZEND_NULL_HANDLER,
64523
16
    ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64524
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64525
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64526
16
    ZEND_NULL_HANDLER,
64527
16
    ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64528
16
    ZEND_SL_SPEC_CONST_CONST_HANDLER,
64529
16
    ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64530
16
    ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64531
16
    ZEND_NULL_HANDLER,
64532
16
    ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64533
16
    ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64534
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64535
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64536
16
    ZEND_NULL_HANDLER,
64537
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64538
16
    ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64539
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64540
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64541
16
    ZEND_NULL_HANDLER,
64542
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64543
16
    ZEND_NULL_HANDLER,
64544
16
    ZEND_NULL_HANDLER,
64545
16
    ZEND_NULL_HANDLER,
64546
16
    ZEND_NULL_HANDLER,
64547
16
    ZEND_NULL_HANDLER,
64548
16
    ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64549
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64550
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64551
16
    ZEND_NULL_HANDLER,
64552
16
    ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64553
16
    ZEND_SR_SPEC_CONST_CONST_HANDLER,
64554
16
    ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64555
16
    ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64556
16
    ZEND_NULL_HANDLER,
64557
16
    ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64558
16
    ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64559
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64560
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64561
16
    ZEND_NULL_HANDLER,
64562
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64563
16
    ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64564
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64565
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64566
16
    ZEND_NULL_HANDLER,
64567
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64568
16
    ZEND_NULL_HANDLER,
64569
16
    ZEND_NULL_HANDLER,
64570
16
    ZEND_NULL_HANDLER,
64571
16
    ZEND_NULL_HANDLER,
64572
16
    ZEND_NULL_HANDLER,
64573
16
    ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64574
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64575
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64576
16
    ZEND_NULL_HANDLER,
64577
16
    ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64578
16
    ZEND_NULL_HANDLER,
64579
16
    ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64580
16
    ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64581
16
    ZEND_NULL_HANDLER,
64582
16
    ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
64583
16
    ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64584
16
    ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64585
16
    ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64586
16
    ZEND_NULL_HANDLER,
64587
16
    ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64588
16
    ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64589
16
    ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64590
16
    ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64591
16
    ZEND_NULL_HANDLER,
64592
16
    ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64593
16
    ZEND_NULL_HANDLER,
64594
16
    ZEND_NULL_HANDLER,
64595
16
    ZEND_NULL_HANDLER,
64596
16
    ZEND_NULL_HANDLER,
64597
16
    ZEND_NULL_HANDLER,
64598
16
    ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
64599
16
    ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64600
16
    ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64601
16
    ZEND_NULL_HANDLER,
64602
16
    ZEND_CONCAT_SPEC_CV_CV_HANDLER,
64603
16
    ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
64604
16
    ZEND_NULL_HANDLER,
64605
16
    ZEND_NULL_HANDLER,
64606
16
    ZEND_NULL_HANDLER,
64607
16
    ZEND_NULL_HANDLER,
64608
16
    ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64609
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64610
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64611
16
    ZEND_NULL_HANDLER,
64612
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64613
16
    ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64614
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64615
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64616
16
    ZEND_NULL_HANDLER,
64617
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64618
16
    ZEND_NULL_HANDLER,
64619
16
    ZEND_NULL_HANDLER,
64620
16
    ZEND_NULL_HANDLER,
64621
16
    ZEND_NULL_HANDLER,
64622
16
    ZEND_NULL_HANDLER,
64623
16
    ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64624
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64625
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64626
16
    ZEND_NULL_HANDLER,
64627
16
    ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64628
16
    ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
64629
16
    ZEND_NULL_HANDLER,
64630
16
    ZEND_NULL_HANDLER,
64631
16
    ZEND_NULL_HANDLER,
64632
16
    ZEND_NULL_HANDLER,
64633
16
    ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64634
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64635
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64636
16
    ZEND_NULL_HANDLER,
64637
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64638
16
    ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64639
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64640
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64641
16
    ZEND_NULL_HANDLER,
64642
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64643
16
    ZEND_NULL_HANDLER,
64644
16
    ZEND_NULL_HANDLER,
64645
16
    ZEND_NULL_HANDLER,
64646
16
    ZEND_NULL_HANDLER,
64647
16
    ZEND_NULL_HANDLER,
64648
16
    ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64649
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64650
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64651
16
    ZEND_NULL_HANDLER,
64652
16
    ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64653
16
    ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
64654
16
    ZEND_NULL_HANDLER,
64655
16
    ZEND_NULL_HANDLER,
64656
16
    ZEND_NULL_HANDLER,
64657
16
    ZEND_NULL_HANDLER,
64658
16
    ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64659
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64660
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64661
16
    ZEND_NULL_HANDLER,
64662
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64663
16
    ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64664
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64665
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64666
16
    ZEND_NULL_HANDLER,
64667
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64668
16
    ZEND_NULL_HANDLER,
64669
16
    ZEND_NULL_HANDLER,
64670
16
    ZEND_NULL_HANDLER,
64671
16
    ZEND_NULL_HANDLER,
64672
16
    ZEND_NULL_HANDLER,
64673
16
    ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64674
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64675
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64676
16
    ZEND_NULL_HANDLER,
64677
16
    ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64678
16
    ZEND_POW_SPEC_CONST_CONST_HANDLER,
64679
16
    ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
64680
16
    ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
64681
16
    ZEND_NULL_HANDLER,
64682
16
    ZEND_POW_SPEC_CONST_CV_HANDLER,
64683
16
    ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
64684
16
    ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64685
16
    ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64686
16
    ZEND_NULL_HANDLER,
64687
16
    ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
64688
16
    ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
64689
16
    ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64690
16
    ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64691
16
    ZEND_NULL_HANDLER,
64692
16
    ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
64693
16
    ZEND_NULL_HANDLER,
64694
16
    ZEND_NULL_HANDLER,
64695
16
    ZEND_NULL_HANDLER,
64696
16
    ZEND_NULL_HANDLER,
64697
16
    ZEND_NULL_HANDLER,
64698
16
    ZEND_POW_SPEC_CV_CONST_HANDLER,
64699
16
    ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
64700
16
    ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
64701
16
    ZEND_NULL_HANDLER,
64702
16
    ZEND_POW_SPEC_CV_CV_HANDLER,
64703
16
    ZEND_BW_NOT_SPEC_CONST_HANDLER,
64704
16
    ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64705
16
    ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64706
16
    ZEND_NULL_HANDLER,
64707
16
    ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64708
16
    ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
64709
16
    ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
64710
16
    ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
64711
16
    ZEND_NULL_HANDLER,
64712
16
    ZEND_BOOL_NOT_SPEC_CV_HANDLER,
64713
16
    ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
64714
16
    ZEND_NULL_HANDLER,
64715
16
    ZEND_NULL_HANDLER,
64716
16
    ZEND_NULL_HANDLER,
64717
16
    ZEND_NULL_HANDLER,
64718
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
64719
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64720
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64721
16
    ZEND_NULL_HANDLER,
64722
16
    ZEND_NULL_HANDLER,
64723
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
64724
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64725
16
    ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64726
16
    ZEND_NULL_HANDLER,
64727
16
    ZEND_NULL_HANDLER,
64728
16
    ZEND_NULL_HANDLER,
64729
16
    ZEND_NULL_HANDLER,
64730
16
    ZEND_NULL_HANDLER,
64731
16
    ZEND_NULL_HANDLER,
64732
16
    ZEND_NULL_HANDLER,
64733
16
    ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
64734
16
    ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
64735
16
    ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
64736
16
    ZEND_NULL_HANDLER,
64737
16
    ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
64738
16
    ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
64739
16
    ZEND_NULL_HANDLER,
64740
16
    ZEND_NULL_HANDLER,
64741
16
    ZEND_NULL_HANDLER,
64742
16
    ZEND_NULL_HANDLER,
64743
16
    ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
64744
16
    ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
64745
16
    ZEND_NULL_HANDLER,
64746
16
    ZEND_NULL_HANDLER,
64747
16
    ZEND_NULL_HANDLER,
64748
16
    ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
64749
16
    ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
64750
16
    ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
64751
16
    ZEND_NULL_HANDLER,
64752
16
    ZEND_NULL_HANDLER,
64753
16
    ZEND_NULL_HANDLER,
64754
16
    ZEND_NULL_HANDLER,
64755
16
    ZEND_NULL_HANDLER,
64756
16
    ZEND_NULL_HANDLER,
64757
16
    ZEND_NULL_HANDLER,
64758
16
    ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
64759
16
    ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
64760
16
    ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
64761
16
    ZEND_NULL_HANDLER,
64762
16
    ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
64763
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
64764
16
    ZEND_NULL_HANDLER,
64765
16
    ZEND_NULL_HANDLER,
64766
16
    ZEND_NULL_HANDLER,
64767
16
    ZEND_NULL_HANDLER,
64768
16
    ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
64769
16
    ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
64770
16
    ZEND_NULL_HANDLER,
64771
16
    ZEND_NULL_HANDLER,
64772
16
    ZEND_NULL_HANDLER,
64773
16
    ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
64774
16
    ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
64775
16
    ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
64776
16
    ZEND_NULL_HANDLER,
64777
16
    ZEND_NULL_HANDLER,
64778
16
    ZEND_NULL_HANDLER,
64779
16
    ZEND_NULL_HANDLER,
64780
16
    ZEND_NULL_HANDLER,
64781
16
    ZEND_NULL_HANDLER,
64782
16
    ZEND_NULL_HANDLER,
64783
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
64784
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
64785
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
64786
16
    ZEND_NULL_HANDLER,
64787
16
    ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
64788
16
    ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64789
16
    ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64790
16
    ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64791
16
    ZEND_NULL_HANDLER,
64792
16
    ZEND_NULL_HANDLER,
64793
16
    ZEND_NULL_HANDLER,
64794
16
    ZEND_NULL_HANDLER,
64795
16
    ZEND_NULL_HANDLER,
64796
16
    ZEND_NULL_HANDLER,
64797
16
    ZEND_NULL_HANDLER,
64798
16
    ZEND_NULL_HANDLER,
64799
16
    ZEND_NULL_HANDLER,
64800
16
    ZEND_NULL_HANDLER,
64801
16
    ZEND_NULL_HANDLER,
64802
16
    ZEND_NULL_HANDLER,
64803
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64804
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64805
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64806
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64807
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64808
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64809
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64810
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64811
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64812
16
    ZEND_NULL_HANDLER,
64813
16
    ZEND_NULL_HANDLER,
64814
16
    ZEND_NULL_HANDLER,
64815
16
    ZEND_NULL_HANDLER,
64816
16
    ZEND_NULL_HANDLER,
64817
16
    ZEND_NULL_HANDLER,
64818
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64819
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64820
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64821
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64822
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64823
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64824
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64825
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64826
16
    ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_NULL_HANDLER,
64841
16
    ZEND_NULL_HANDLER,
64842
16
    ZEND_NULL_HANDLER,
64843
16
    ZEND_NULL_HANDLER,
64844
16
    ZEND_NULL_HANDLER,
64845
16
    ZEND_NULL_HANDLER,
64846
16
    ZEND_NULL_HANDLER,
64847
16
    ZEND_NULL_HANDLER,
64848
16
    ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
64849
16
    ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
64850
16
    ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
64851
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64852
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64853
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64854
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64855
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64856
16
    ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64857
16
    ZEND_NULL_HANDLER,
64858
16
    ZEND_NULL_HANDLER,
64859
16
    ZEND_NULL_HANDLER,
64860
16
    ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
64861
16
    ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
64862
16
    ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
64863
16
    ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64864
16
    ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64865
16
    ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64866
16
    ZEND_NULL_HANDLER,
64867
16
    ZEND_NULL_HANDLER,
64868
16
    ZEND_NULL_HANDLER,
64869
16
    ZEND_NULL_HANDLER,
64870
16
    ZEND_NULL_HANDLER,
64871
16
    ZEND_NULL_HANDLER,
64872
16
    ZEND_NULL_HANDLER,
64873
16
    ZEND_NULL_HANDLER,
64874
16
    ZEND_NULL_HANDLER,
64875
16
    ZEND_NULL_HANDLER,
64876
16
    ZEND_NULL_HANDLER,
64877
16
    ZEND_NULL_HANDLER,
64878
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64879
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64880
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64881
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64882
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64883
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64884
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64885
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64886
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64887
16
    ZEND_NULL_HANDLER,
64888
16
    ZEND_NULL_HANDLER,
64889
16
    ZEND_NULL_HANDLER,
64890
16
    ZEND_NULL_HANDLER,
64891
16
    ZEND_NULL_HANDLER,
64892
16
    ZEND_NULL_HANDLER,
64893
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64894
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64895
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64896
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64897
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64898
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64899
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64900
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64901
16
    ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_NULL_HANDLER,
64916
16
    ZEND_NULL_HANDLER,
64917
16
    ZEND_NULL_HANDLER,
64918
16
    ZEND_NULL_HANDLER,
64919
16
    ZEND_NULL_HANDLER,
64920
16
    ZEND_NULL_HANDLER,
64921
16
    ZEND_NULL_HANDLER,
64922
16
    ZEND_NULL_HANDLER,
64923
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
64924
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
64925
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
64926
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64927
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64928
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64929
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64930
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64931
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64932
16
    ZEND_NULL_HANDLER,
64933
16
    ZEND_NULL_HANDLER,
64934
16
    ZEND_NULL_HANDLER,
64935
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
64936
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
64937
16
    ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
64938
16
    ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64939
16
    ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64940
16
    ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64941
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64942
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64943
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64944
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64945
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64946
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64947
16
    ZEND_NULL_HANDLER,
64948
16
    ZEND_NULL_HANDLER,
64949
16
    ZEND_NULL_HANDLER,
64950
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64951
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64952
16
    ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64953
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64954
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64955
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64956
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64957
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64958
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64959
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64960
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64961
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64962
16
    ZEND_NULL_HANDLER,
64963
16
    ZEND_NULL_HANDLER,
64964
16
    ZEND_NULL_HANDLER,
64965
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64966
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64967
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64968
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64969
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64970
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64971
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64972
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64973
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64974
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64975
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64976
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64977
16
    ZEND_NULL_HANDLER,
64978
16
    ZEND_NULL_HANDLER,
64979
16
    ZEND_NULL_HANDLER,
64980
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64981
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64982
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
64991
16
    ZEND_NULL_HANDLER,
64992
16
    ZEND_NULL_HANDLER,
64993
16
    ZEND_NULL_HANDLER,
64994
16
    ZEND_NULL_HANDLER,
64995
16
    ZEND_NULL_HANDLER,
64996
16
    ZEND_NULL_HANDLER,
64997
16
    ZEND_NULL_HANDLER,
64998
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64999
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65000
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65001
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65002
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65003
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65004
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65005
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65006
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65007
16
    ZEND_NULL_HANDLER,
65008
16
    ZEND_NULL_HANDLER,
65009
16
    ZEND_NULL_HANDLER,
65010
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65011
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65012
16
    ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65013
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
65014
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
65015
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
65016
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
65017
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65018
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65019
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
65020
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65021
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65022
16
    ZEND_NULL_HANDLER,
65023
16
    ZEND_NULL_HANDLER,
65024
16
    ZEND_NULL_HANDLER,
65025
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
65026
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65027
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65028
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
65029
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65030
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65031
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65032
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65033
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65034
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65035
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65036
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65037
16
    ZEND_NULL_HANDLER,
65038
16
    ZEND_NULL_HANDLER,
65039
16
    ZEND_NULL_HANDLER,
65040
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65041
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65042
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65043
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
65044
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65045
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65046
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65047
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65048
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65049
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65050
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65051
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65052
16
    ZEND_NULL_HANDLER,
65053
16
    ZEND_NULL_HANDLER,
65054
16
    ZEND_NULL_HANDLER,
65055
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65056
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65057
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
65066
16
    ZEND_NULL_HANDLER,
65067
16
    ZEND_NULL_HANDLER,
65068
16
    ZEND_NULL_HANDLER,
65069
16
    ZEND_NULL_HANDLER,
65070
16
    ZEND_NULL_HANDLER,
65071
16
    ZEND_NULL_HANDLER,
65072
16
    ZEND_NULL_HANDLER,
65073
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
65074
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65075
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65076
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65077
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65078
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65079
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65080
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65081
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65082
16
    ZEND_NULL_HANDLER,
65083
16
    ZEND_NULL_HANDLER,
65084
16
    ZEND_NULL_HANDLER,
65085
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65086
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65087
16
    ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
65101
16
    ZEND_NULL_HANDLER,
65102
16
    ZEND_NULL_HANDLER,
65103
16
    ZEND_NULL_HANDLER,
65104
16
    ZEND_NULL_HANDLER,
65105
16
    ZEND_NULL_HANDLER,
65106
16
    ZEND_NULL_HANDLER,
65107
16
    ZEND_NULL_HANDLER,
65108
16
    ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER,
65109
16
    ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER,
65110
16
    ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER,
65111
16
    ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER,
65112
16
    ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER,
65113
16
    ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER,
65114
16
    ZEND_NULL_HANDLER,
65115
16
    ZEND_NULL_HANDLER,
65116
16
    ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
65117
16
    ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER,
65118
16
    ZEND_NULL_HANDLER,
65119
16
    ZEND_NULL_HANDLER,
65120
16
    ZEND_NULL_HANDLER,
65121
16
    ZEND_NULL_HANDLER,
65122
16
    ZEND_NULL_HANDLER,
65123
16
    ZEND_NULL_HANDLER,
65124
16
    ZEND_NULL_HANDLER,
65125
16
    ZEND_NULL_HANDLER,
65126
16
    ZEND_NULL_HANDLER,
65127
16
    ZEND_NULL_HANDLER,
65128
16
    ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER,
65129
16
    ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER,
65130
16
    ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER,
65131
16
    ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER,
65132
16
    ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER,
65133
16
    ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER,
65134
16
    ZEND_NULL_HANDLER,
65135
16
    ZEND_NULL_HANDLER,
65136
16
    ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER,
65137
16
    ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_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_NULL_HANDLER,
65181
16
    ZEND_NULL_HANDLER,
65182
16
    ZEND_NULL_HANDLER,
65183
16
    ZEND_NULL_HANDLER,
65184
16
    ZEND_NULL_HANDLER,
65185
16
    ZEND_NULL_HANDLER,
65186
16
    ZEND_NULL_HANDLER,
65187
16
    ZEND_NULL_HANDLER,
65188
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
65189
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
65190
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65191
16
    ZEND_NULL_HANDLER,
65192
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65193
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65194
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65195
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65196
16
    ZEND_NULL_HANDLER,
65197
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65198
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65199
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65200
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65201
16
    ZEND_NULL_HANDLER,
65202
16
    ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65203
16
    ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER,
65204
16
    ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER,
65205
16
    ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER,
65206
16
    ZEND_NULL_HANDLER,
65207
16
    ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER,
65208
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
65209
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
65210
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65211
16
    ZEND_NULL_HANDLER,
65212
16
    ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_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_NULL_HANDLER,
65231
16
    ZEND_NULL_HANDLER,
65232
16
    ZEND_NULL_HANDLER,
65233
16
    ZEND_NULL_HANDLER,
65234
16
    ZEND_NULL_HANDLER,
65235
16
    ZEND_NULL_HANDLER,
65236
16
    ZEND_NULL_HANDLER,
65237
16
    ZEND_NULL_HANDLER,
65238
16
    ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
65239
16
    ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
65240
16
    ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65241
16
    ZEND_NULL_HANDLER,
65242
16
    ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65243
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65244
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65245
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65246
16
    ZEND_NULL_HANDLER,
65247
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65248
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65249
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65250
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65251
16
    ZEND_NULL_HANDLER,
65252
16
    ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65253
16
    ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER,
65254
16
    ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER,
65255
16
    ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER,
65256
16
    ZEND_NULL_HANDLER,
65257
16
    ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER,
65258
16
    ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
65259
16
    ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
65260
16
    ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65261
16
    ZEND_NULL_HANDLER,
65262
16
    ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_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_NULL_HANDLER,
65306
16
    ZEND_NULL_HANDLER,
65307
16
    ZEND_NULL_HANDLER,
65308
16
    ZEND_NULL_HANDLER,
65309
16
    ZEND_NULL_HANDLER,
65310
16
    ZEND_NULL_HANDLER,
65311
16
    ZEND_NULL_HANDLER,
65312
16
    ZEND_NULL_HANDLER,
65313
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
65314
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
65315
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65316
16
    ZEND_NULL_HANDLER,
65317
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65318
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65319
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65320
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65321
16
    ZEND_NULL_HANDLER,
65322
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65323
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65324
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65325
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65326
16
    ZEND_NULL_HANDLER,
65327
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65328
16
    ZEND_NULL_HANDLER,
65329
16
    ZEND_NULL_HANDLER,
65330
16
    ZEND_NULL_HANDLER,
65331
16
    ZEND_NULL_HANDLER,
65332
16
    ZEND_NULL_HANDLER,
65333
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
65334
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
65335
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65336
16
    ZEND_NULL_HANDLER,
65337
16
    ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65338
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER,
65339
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER,
65340
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
65341
16
    ZEND_NULL_HANDLER,
65342
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
65343
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
65344
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
65345
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65346
16
    ZEND_NULL_HANDLER,
65347
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65348
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
65349
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
65350
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65351
16
    ZEND_NULL_HANDLER,
65352
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65353
16
    ZEND_NULL_HANDLER,
65354
16
    ZEND_NULL_HANDLER,
65355
16
    ZEND_NULL_HANDLER,
65356
16
    ZEND_NULL_HANDLER,
65357
16
    ZEND_NULL_HANDLER,
65358
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER,
65359
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER,
65360
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
65361
16
    ZEND_NULL_HANDLER,
65362
16
    ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
65363
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
65364
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
65365
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65366
16
    ZEND_NULL_HANDLER,
65367
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65368
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65369
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65370
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65371
16
    ZEND_NULL_HANDLER,
65372
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65373
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65374
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65375
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65376
16
    ZEND_NULL_HANDLER,
65377
16
    ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65378
16
    ZEND_NULL_HANDLER,
65379
16
    ZEND_NULL_HANDLER,
65380
16
    ZEND_NULL_HANDLER,
65381
16
    ZEND_NULL_HANDLER,
65382
16
    ZEND_NULL_HANDLER,
65383
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
65384
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
65385
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65386
16
    ZEND_NULL_HANDLER,
65387
16
    ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65388
16
    ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER,
65389
16
    ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER,
65390
16
    ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER,
65391
16
    ZEND_NULL_HANDLER,
65392
16
    ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER,
65393
16
    ZEND_NULL_HANDLER,
65394
16
    ZEND_NULL_HANDLER,
65395
16
    ZEND_NULL_HANDLER,
65396
16
    ZEND_NULL_HANDLER,
65397
16
    ZEND_NULL_HANDLER,
65398
16
    ZEND_NULL_HANDLER,
65399
16
    ZEND_NULL_HANDLER,
65400
16
    ZEND_NULL_HANDLER,
65401
16
    ZEND_NULL_HANDLER,
65402
16
    ZEND_NULL_HANDLER,
65403
16
    ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER,
65404
16
    ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
65405
16
    ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
65406
16
    ZEND_NULL_HANDLER,
65407
16
    ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER,
65408
16
    ZEND_NULL_HANDLER,
65409
16
    ZEND_NULL_HANDLER,
65410
16
    ZEND_NULL_HANDLER,
65411
16
    ZEND_NULL_HANDLER,
65412
16
    ZEND_NULL_HANDLER,
65413
16
    ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER,
65414
16
    ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
65415
16
    ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
65416
16
    ZEND_NULL_HANDLER,
65417
16
    ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER,
65418
16
    ZEND_NULL_HANDLER,
65419
16
    ZEND_NULL_HANDLER,
65420
16
    ZEND_NULL_HANDLER,
65421
16
    ZEND_NULL_HANDLER,
65422
16
    ZEND_NULL_HANDLER,
65423
16
    ZEND_NULL_HANDLER,
65424
16
    ZEND_NULL_HANDLER,
65425
16
    ZEND_NULL_HANDLER,
65426
16
    ZEND_NULL_HANDLER,
65427
16
    ZEND_NULL_HANDLER,
65428
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER,
65429
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
65430
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
65431
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER,
65432
16
    ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER,
65433
16
    ZEND_NULL_HANDLER,
65434
16
    ZEND_NULL_HANDLER,
65435
16
    ZEND_NULL_HANDLER,
65436
16
    ZEND_NULL_HANDLER,
65437
16
    ZEND_NULL_HANDLER,
65438
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER,
65439
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
65440
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
65441
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER,
65442
16
    ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER,
65443
16
    ZEND_NULL_HANDLER,
65444
16
    ZEND_NULL_HANDLER,
65445
16
    ZEND_NULL_HANDLER,
65446
16
    ZEND_NULL_HANDLER,
65447
16
    ZEND_NULL_HANDLER,
65448
16
    ZEND_NULL_HANDLER,
65449
16
    ZEND_NULL_HANDLER,
65450
16
    ZEND_NULL_HANDLER,
65451
16
    ZEND_NULL_HANDLER,
65452
16
    ZEND_NULL_HANDLER,
65453
16
    ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER,
65454
16
    ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
65455
16
    ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
65456
16
    ZEND_NULL_HANDLER,
65457
16
    ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER,
65458
16
    ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER,
65459
16
    ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
65460
16
    ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
65461
16
    ZEND_NULL_HANDLER,
65462
16
    ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER,
65463
16
    ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER,
65464
16
    ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
65465
16
    ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
65466
16
    ZEND_NULL_HANDLER,
65467
16
    ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER,
65468
16
    ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER,
65469
16
    ZEND_NULL_HANDLER,
65470
16
    ZEND_NULL_HANDLER,
65471
16
    ZEND_NULL_HANDLER,
65472
16
    ZEND_NULL_HANDLER,
65473
16
    ZEND_NULL_HANDLER,
65474
16
    ZEND_NULL_HANDLER,
65475
16
    ZEND_NULL_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_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
65482
16
    ZEND_NULL_HANDLER,
65483
16
    ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
65484
16
    ZEND_NULL_HANDLER,
65485
16
    ZEND_NULL_HANDLER,
65486
16
    ZEND_NULL_HANDLER,
65487
16
    ZEND_NULL_HANDLER,
65488
16
    ZEND_NULL_HANDLER,
65489
16
    ZEND_NULL_HANDLER,
65490
16
    ZEND_NULL_HANDLER,
65491
16
    ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
65492
16
    ZEND_NULL_HANDLER,
65493
16
    ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
65494
16
    ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
65495
16
    ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
65496
16
    ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
65497
16
    ZEND_NULL_HANDLER,
65498
16
    ZEND_QM_ASSIGN_SPEC_CV_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_NULL_HANDLER,
65544
16
    ZEND_NULL_HANDLER,
65545
16
    ZEND_NULL_HANDLER,
65546
16
    ZEND_NULL_HANDLER,
65547
16
    ZEND_NULL_HANDLER,
65548
16
    ZEND_NULL_HANDLER,
65549
16
    ZEND_NULL_HANDLER,
65550
16
    ZEND_NULL_HANDLER,
65551
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65552
16
    ZEND_NULL_HANDLER,
65553
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65554
16
    ZEND_NULL_HANDLER,
65555
16
    ZEND_NULL_HANDLER,
65556
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65557
16
    ZEND_NULL_HANDLER,
65558
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65559
16
    ZEND_NULL_HANDLER,
65560
16
    ZEND_NULL_HANDLER,
65561
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65562
16
    ZEND_NULL_HANDLER,
65563
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65564
16
    ZEND_NULL_HANDLER,
65565
16
    ZEND_NULL_HANDLER,
65566
16
    ZEND_NULL_HANDLER,
65567
16
    ZEND_NULL_HANDLER,
65568
16
    ZEND_NULL_HANDLER,
65569
16
    ZEND_NULL_HANDLER,
65570
16
    ZEND_NULL_HANDLER,
65571
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65572
16
    ZEND_NULL_HANDLER,
65573
16
    ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65574
16
    ZEND_NULL_HANDLER,
65575
16
    ZEND_NULL_HANDLER,
65576
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
65577
16
    ZEND_NULL_HANDLER,
65578
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
65579
16
    ZEND_NULL_HANDLER,
65580
16
    ZEND_NULL_HANDLER,
65581
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65582
16
    ZEND_NULL_HANDLER,
65583
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65584
16
    ZEND_NULL_HANDLER,
65585
16
    ZEND_NULL_HANDLER,
65586
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65587
16
    ZEND_NULL_HANDLER,
65588
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65589
16
    ZEND_NULL_HANDLER,
65590
16
    ZEND_NULL_HANDLER,
65591
16
    ZEND_NULL_HANDLER,
65592
16
    ZEND_NULL_HANDLER,
65593
16
    ZEND_NULL_HANDLER,
65594
16
    ZEND_NULL_HANDLER,
65595
16
    ZEND_NULL_HANDLER,
65596
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
65597
16
    ZEND_NULL_HANDLER,
65598
16
    ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
65599
16
    ZEND_NULL_HANDLER,
65600
16
    ZEND_NULL_HANDLER,
65601
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65602
16
    ZEND_NULL_HANDLER,
65603
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65604
16
    ZEND_NULL_HANDLER,
65605
16
    ZEND_NULL_HANDLER,
65606
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65607
16
    ZEND_NULL_HANDLER,
65608
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65609
16
    ZEND_NULL_HANDLER,
65610
16
    ZEND_NULL_HANDLER,
65611
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65612
16
    ZEND_NULL_HANDLER,
65613
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65614
16
    ZEND_NULL_HANDLER,
65615
16
    ZEND_NULL_HANDLER,
65616
16
    ZEND_NULL_HANDLER,
65617
16
    ZEND_NULL_HANDLER,
65618
16
    ZEND_NULL_HANDLER,
65619
16
    ZEND_NULL_HANDLER,
65620
16
    ZEND_NULL_HANDLER,
65621
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65622
16
    ZEND_NULL_HANDLER,
65623
16
    ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65624
16
    ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER,
65625
16
    ZEND_NULL_HANDLER,
65626
16
    ZEND_NULL_HANDLER,
65627
16
    ZEND_NULL_HANDLER,
65628
16
    ZEND_NULL_HANDLER,
65629
16
    ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
65630
16
    ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER,
65631
16
    ZEND_NULL_HANDLER,
65632
16
    ZEND_NULL_HANDLER,
65633
16
    ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER,
65634
16
    ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER,
65635
16
    ZEND_NULL_HANDLER,
65636
16
    ZEND_NULL_HANDLER,
65637
16
    ZEND_NULL_HANDLER,
65638
16
    ZEND_NULL_HANDLER,
65639
16
    ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
65640
16
    ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER,
65641
16
    ZEND_NULL_HANDLER,
65642
16
    ZEND_NULL_HANDLER,
65643
16
    ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER,
65644
16
    ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER,
65645
16
    ZEND_NULL_HANDLER,
65646
16
    ZEND_NULL_HANDLER,
65647
16
    ZEND_POST_INC_SPEC_VAR_HANDLER,
65648
16
    ZEND_NULL_HANDLER,
65649
16
    ZEND_POST_INC_SPEC_CV_HANDLER,
65650
16
    ZEND_NULL_HANDLER,
65651
16
    ZEND_NULL_HANDLER,
65652
16
    ZEND_POST_DEC_SPEC_VAR_HANDLER,
65653
16
    ZEND_NULL_HANDLER,
65654
16
    ZEND_POST_DEC_SPEC_CV_HANDLER,
65655
16
    ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER,
65656
16
    ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER,
65657
16
    ZEND_JMP_SPEC_HANDLER,
65658
16
    ZEND_JMPZ_SPEC_CONST_HANDLER,
65659
16
    ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
65660
16
    ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
65661
16
    ZEND_NULL_HANDLER,
65662
16
    ZEND_JMPZ_SPEC_CV_HANDLER,
65663
16
    ZEND_JMPNZ_SPEC_CONST_HANDLER,
65664
16
    ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
65665
16
    ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
65666
16
    ZEND_NULL_HANDLER,
65667
16
    ZEND_JMPNZ_SPEC_CV_HANDLER,
65668
16
    ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
65669
16
    ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
65670
16
    ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
65671
16
    ZEND_NULL_HANDLER,
65672
16
    ZEND_JMPZ_EX_SPEC_CV_HANDLER,
65673
16
    ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
65674
16
    ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
65675
16
    ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
65676
16
    ZEND_NULL_HANDLER,
65677
16
    ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
65678
16
    ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER,
65679
16
    ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
65680
16
    ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
65681
16
    ZEND_NULL_HANDLER,
65682
16
    ZEND_CASE_SPEC_TMPVAR_CV_HANDLER,
65683
16
    ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER,
65684
16
    ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
65685
16
    ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
65686
16
    ZEND_NULL_HANDLER,
65687
16
    ZEND_NULL_HANDLER,
65688
16
    ZEND_NULL_HANDLER,
65689
16
    ZEND_NULL_HANDLER,
65690
16
    ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER,
65691
16
    ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
65692
16
    ZEND_NULL_HANDLER,
65693
16
    ZEND_NULL_HANDLER,
65694
16
    ZEND_CAST_SPEC_CONST_HANDLER,
65695
16
    ZEND_CAST_SPEC_TMP_HANDLER,
65696
16
    ZEND_CAST_SPEC_VAR_HANDLER,
65697
16
    ZEND_NULL_HANDLER,
65698
16
    ZEND_CAST_SPEC_CV_HANDLER,
65699
16
    ZEND_BOOL_SPEC_CONST_HANDLER,
65700
16
    ZEND_BOOL_SPEC_TMPVAR_HANDLER,
65701
16
    ZEND_BOOL_SPEC_TMPVAR_HANDLER,
65702
16
    ZEND_NULL_HANDLER,
65703
16
    ZEND_BOOL_SPEC_CV_HANDLER,
65704
16
    ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER,
65705
16
    ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
65706
16
    ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
65707
16
    ZEND_NULL_HANDLER,
65708
16
    ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER,
65709
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
65710
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65711
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65712
16
    ZEND_NULL_HANDLER,
65713
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
65714
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
65715
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65716
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65717
16
    ZEND_NULL_HANDLER,
65718
16
    ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
65719
16
    ZEND_NULL_HANDLER,
65720
16
    ZEND_NULL_HANDLER,
65721
16
    ZEND_NULL_HANDLER,
65722
16
    ZEND_NULL_HANDLER,
65723
16
    ZEND_NULL_HANDLER,
65724
16
    ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER,
65725
16
    ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
65726
16
    ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
65727
16
    ZEND_NULL_HANDLER,
65728
16
    ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER,
65729
16
    ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER,
65730
16
    ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
65731
16
    ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
65732
16
    ZEND_NULL_HANDLER,
65733
16
    ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER,
65734
16
    ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER,
65735
16
    ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
65736
16
    ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
65737
16
    ZEND_NULL_HANDLER,
65738
16
    ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER,
65739
16
    ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER,
65740
16
    ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
65741
16
    ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
65742
16
    ZEND_NULL_HANDLER,
65743
16
    ZEND_ROPE_END_SPEC_TMP_CV_HANDLER,
65744
16
    ZEND_BEGIN_SILENCE_SPEC_HANDLER,
65745
16
    ZEND_END_SILENCE_SPEC_TMP_HANDLER,
65746
16
    ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
65747
16
    ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER,
65748
16
    ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER,
65749
16
    ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
65750
16
    ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
65751
16
    ZEND_INIT_FCALL_SPEC_CONST_HANDLER,
65752
16
    ZEND_RETURN_SPEC_CONST_HANDLER,
65753
16
    ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65754
16
    ZEND_RETURN_SPEC_TMP_HANDLER,
65755
16
    ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65756
16
    ZEND_RETURN_SPEC_VAR_HANDLER,
65757
16
    ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65758
16
    ZEND_NULL_HANDLER,
65759
16
    ZEND_NULL_HANDLER,
65760
16
    ZEND_RETURN_SPEC_CV_HANDLER,
65761
16
    ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65762
16
    ZEND_RECV_SPEC_UNUSED_HANDLER,
65763
16
    ZEND_RECV_INIT_SPEC_CONST_HANDLER,
65764
16
    ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER,
65765
16
    ZEND_NULL_HANDLER,
65766
16
    ZEND_NULL_HANDLER,
65767
16
    ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER,
65768
16
    ZEND_NULL_HANDLER,
65769
16
    ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
65770
16
    ZEND_NULL_HANDLER,
65771
16
    ZEND_NULL_HANDLER,
65772
16
    ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
65773
16
    ZEND_NULL_HANDLER,
65774
16
    ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
65775
16
    ZEND_NULL_HANDLER,
65776
16
    ZEND_NULL_HANDLER,
65777
16
    ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_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_NULL_HANDLER,
65802
16
    ZEND_NULL_HANDLER,
65803
16
    ZEND_NULL_HANDLER,
65804
16
    ZEND_NULL_HANDLER,
65805
16
    ZEND_NULL_HANDLER,
65806
16
    ZEND_NULL_HANDLER,
65807
16
    ZEND_NULL_HANDLER,
65808
16
    ZEND_NULL_HANDLER,
65809
16
    ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
65810
16
    ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
65811
16
    ZEND_NULL_HANDLER,
65812
16
    ZEND_NULL_HANDLER,
65813
16
    ZEND_NULL_HANDLER,
65814
16
    ZEND_NULL_HANDLER,
65815
16
    ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER,
65816
16
    ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
65817
16
    ZEND_NULL_HANDLER,
65818
16
    ZEND_NULL_HANDLER,
65819
16
    ZEND_NULL_HANDLER,
65820
16
    ZEND_NULL_HANDLER,
65821
16
    ZEND_NULL_HANDLER,
65822
16
    ZEND_NULL_HANDLER,
65823
16
    ZEND_NULL_HANDLER,
65824
16
    ZEND_NULL_HANDLER,
65825
16
    ZEND_NULL_HANDLER,
65826
16
    ZEND_NULL_HANDLER,
65827
16
    ZEND_NULL_HANDLER,
65828
16
    ZEND_NULL_HANDLER,
65829
16
    ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
65830
16
    ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
65831
16
    ZEND_NULL_HANDLER,
65832
16
    ZEND_NULL_HANDLER,
65833
16
    ZEND_NULL_HANDLER,
65834
16
    ZEND_NULL_HANDLER,
65835
16
    ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER,
65836
16
    ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER,
65837
16
    ZEND_NULL_HANDLER,
65838
16
    ZEND_NULL_HANDLER,
65839
16
    ZEND_NULL_HANDLER,
65840
16
    ZEND_NULL_HANDLER,
65841
16
    ZEND_NULL_HANDLER,
65842
16
    ZEND_NULL_HANDLER,
65843
16
    ZEND_NULL_HANDLER,
65844
16
    ZEND_NULL_HANDLER,
65845
16
    ZEND_NULL_HANDLER,
65846
16
    ZEND_NULL_HANDLER,
65847
16
    ZEND_NULL_HANDLER,
65848
16
    ZEND_NULL_HANDLER,
65849
16
    ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER,
65850
16
    ZEND_NULL_HANDLER,
65851
16
    ZEND_NULL_HANDLER,
65852
16
    ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER,
65853
16
    ZEND_NULL_HANDLER,
65854
16
    ZEND_NULL_HANDLER,
65855
16
    ZEND_NULL_HANDLER,
65856
16
    ZEND_NULL_HANDLER,
65857
16
    ZEND_NULL_HANDLER,
65858
16
    ZEND_NULL_HANDLER,
65859
16
    ZEND_SEND_REF_SPEC_CV_CONST_HANDLER,
65860
16
    ZEND_NULL_HANDLER,
65861
16
    ZEND_NULL_HANDLER,
65862
16
    ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER,
65863
16
    ZEND_NULL_HANDLER,
65864
16
    ZEND_NEW_SPEC_CONST_UNUSED_HANDLER,
65865
16
    ZEND_NULL_HANDLER,
65866
16
    ZEND_NEW_SPEC_VAR_UNUSED_HANDLER,
65867
16
    ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER,
65868
16
    ZEND_NULL_HANDLER,
65869
16
    ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
65870
16
    ZEND_FREE_SPEC_TMPVAR_HANDLER,
65871
16
    ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
65872
16
    ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
65873
16
    ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
65874
16
    ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
65875
16
    ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
65876
16
    ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
65877
16
    ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
65878
16
    ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
65879
16
    ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
65880
16
    ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
65881
16
    ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
65882
16
    ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
65883
16
    ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
65884
16
    ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
65885
16
    ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
65886
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
65887
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
65888
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
65889
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
65890
16
    ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
65891
16
    ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
65892
16
    ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
65893
16
    ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
65894
16
    ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
65895
16
    ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
65896
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
65897
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
65898
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
65899
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
65900
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
65901
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
65902
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
65903
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
65904
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
65905
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
65906
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
65907
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
65908
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
65909
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
65910
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
65911
16
    ZEND_NULL_HANDLER,
65912
16
    ZEND_NULL_HANDLER,
65913
16
    ZEND_NULL_HANDLER,
65914
16
    ZEND_NULL_HANDLER,
65915
16
    ZEND_NULL_HANDLER,
65916
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
65917
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
65918
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
65919
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
65920
16
    ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
65921
16
    ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
65922
16
    ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65923
16
    ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
65924
16
    ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65925
16
    ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
65926
16
    ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65927
16
    ZEND_NULL_HANDLER,
65928
16
    ZEND_NULL_HANDLER,
65929
16
    ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
65930
16
    ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65931
16
    ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
65932
16
    ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
65933
16
    ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
65934
16
    ZEND_NULL_HANDLER,
65935
16
    ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
65936
16
    ZEND_NULL_HANDLER,
65937
16
    ZEND_NULL_HANDLER,
65938
16
    ZEND_NULL_HANDLER,
65939
16
    ZEND_NULL_HANDLER,
65940
16
    ZEND_NULL_HANDLER,
65941
16
    ZEND_NULL_HANDLER,
65942
16
    ZEND_NULL_HANDLER,
65943
16
    ZEND_NULL_HANDLER,
65944
16
    ZEND_NULL_HANDLER,
65945
16
    ZEND_NULL_HANDLER,
65946
16
    ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
65947
16
    ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
65948
16
    ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
65949
16
    ZEND_NULL_HANDLER,
65950
16
    ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
65951
16
    ZEND_NULL_HANDLER,
65952
16
    ZEND_NULL_HANDLER,
65953
16
    ZEND_NULL_HANDLER,
65954
16
    ZEND_NULL_HANDLER,
65955
16
    ZEND_NULL_HANDLER,
65956
16
    ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
65957
16
    ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
65958
16
    ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
65959
16
    ZEND_NULL_HANDLER,
65960
16
    ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
65961
16
    ZEND_NULL_HANDLER,
65962
16
    ZEND_NULL_HANDLER,
65963
16
    ZEND_NULL_HANDLER,
65964
16
    ZEND_NULL_HANDLER,
65965
16
    ZEND_NULL_HANDLER,
65966
16
    ZEND_NULL_HANDLER,
65967
16
    ZEND_NULL_HANDLER,
65968
16
    ZEND_NULL_HANDLER,
65969
16
    ZEND_NULL_HANDLER,
65970
16
    ZEND_NULL_HANDLER,
65971
16
    ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
65972
16
    ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65973
16
    ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65974
16
    ZEND_NULL_HANDLER,
65975
16
    ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
65976
16
    ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
65977
16
    ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65978
16
    ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65979
16
    ZEND_NULL_HANDLER,
65980
16
    ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
65981
16
    ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
65982
16
    ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
65983
16
    ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
65984
16
    ZEND_NULL_HANDLER,
65985
16
    ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
65986
16
    ZEND_FE_RESET_R_SPEC_CONST_HANDLER,
65987
16
    ZEND_FE_RESET_R_SPEC_TMP_HANDLER,
65988
16
    ZEND_FE_RESET_R_SPEC_VAR_HANDLER,
65989
16
    ZEND_NULL_HANDLER,
65990
16
    ZEND_FE_RESET_R_SPEC_CV_HANDLER,
65991
16
    ZEND_FE_FETCH_R_SPEC_VAR_HANDLER,
65992
16
    ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
65993
16
    ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
65994
16
    ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
65995
16
    ZEND_NULL_HANDLER,
65996
16
    ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
65997
16
    ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
65998
16
    ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
65999
16
    ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
66000
16
    ZEND_NULL_HANDLER,
66001
16
    ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
66002
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
66003
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66004
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66005
16
    ZEND_NULL_HANDLER,
66006
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
66007
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
66008
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66009
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66010
16
    ZEND_NULL_HANDLER,
66011
16
    ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
66012
16
    ZEND_NULL_HANDLER,
66013
16
    ZEND_NULL_HANDLER,
66014
16
    ZEND_NULL_HANDLER,
66015
16
    ZEND_NULL_HANDLER,
66016
16
    ZEND_NULL_HANDLER,
66017
16
    ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
66018
16
    ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
66019
16
    ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
66020
16
    ZEND_NULL_HANDLER,
66021
16
    ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
66022
16
    ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER,
66023
16
    ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
66024
16
    ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
66025
16
    ZEND_NULL_HANDLER,
66026
16
    ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER,
66027
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
66028
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66029
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66030
16
    ZEND_NULL_HANDLER,
66031
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
66032
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
66033
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66034
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
66035
16
    ZEND_NULL_HANDLER,
66036
16
    ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
66037
16
    ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
66038
16
    ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
66039
16
    ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
66040
16
    ZEND_NULL_HANDLER,
66041
16
    ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
66042
16
    ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
66043
16
    ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
66044
16
    ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
66045
16
    ZEND_NULL_HANDLER,
66046
16
    ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
66047
16
    ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
66048
16
    ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
66049
16
    ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
66050
16
    ZEND_NULL_HANDLER,
66051
16
    ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
66052
16
    ZEND_NULL_HANDLER,
66053
16
    ZEND_NULL_HANDLER,
66054
16
    ZEND_NULL_HANDLER,
66055
16
    ZEND_NULL_HANDLER,
66056
16
    ZEND_NULL_HANDLER,
66057
16
    ZEND_NULL_HANDLER,
66058
16
    ZEND_NULL_HANDLER,
66059
16
    ZEND_NULL_HANDLER,
66060
16
    ZEND_NULL_HANDLER,
66061
16
    ZEND_NULL_HANDLER,
66062
16
    ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
66063
16
    ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
66064
16
    ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
66065
16
    ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
66066
16
    ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
66067
16
    ZEND_NULL_HANDLER,
66068
16
    ZEND_NULL_HANDLER,
66069
16
    ZEND_NULL_HANDLER,
66070
16
    ZEND_NULL_HANDLER,
66071
16
    ZEND_NULL_HANDLER,
66072
16
    ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
66073
16
    ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
66074
16
    ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
66075
16
    ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
66076
16
    ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
66077
16
    ZEND_NULL_HANDLER,
66078
16
    ZEND_NULL_HANDLER,
66079
16
    ZEND_NULL_HANDLER,
66080
16
    ZEND_NULL_HANDLER,
66081
16
    ZEND_NULL_HANDLER,
66082
16
    ZEND_NULL_HANDLER,
66083
16
    ZEND_NULL_HANDLER,
66084
16
    ZEND_NULL_HANDLER,
66085
16
    ZEND_NULL_HANDLER,
66086
16
    ZEND_NULL_HANDLER,
66087
16
    ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
66088
16
    ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
66089
16
    ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
66090
16
    ZEND_NULL_HANDLER,
66091
16
    ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
66092
16
    ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
66093
16
    ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
66094
16
    ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
66095
16
    ZEND_NULL_HANDLER,
66096
16
    ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
66097
16
    ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
66098
16
    ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
66099
16
    ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
66100
16
    ZEND_NULL_HANDLER,
66101
16
    ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
66102
16
    ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
66103
16
    ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
66104
16
    ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
66105
16
    ZEND_NULL_HANDLER,
66106
16
    ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
66107
16
    ZEND_NULL_HANDLER,
66108
16
    ZEND_NULL_HANDLER,
66109
16
    ZEND_NULL_HANDLER,
66110
16
    ZEND_NULL_HANDLER,
66111
16
    ZEND_NULL_HANDLER,
66112
16
    ZEND_NULL_HANDLER,
66113
16
    ZEND_NULL_HANDLER,
66114
16
    ZEND_NULL_HANDLER,
66115
16
    ZEND_NULL_HANDLER,
66116
16
    ZEND_NULL_HANDLER,
66117
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
66118
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
66119
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
66120
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
66121
16
    ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
66122
16
    ZEND_NULL_HANDLER,
66123
16
    ZEND_NULL_HANDLER,
66124
16
    ZEND_NULL_HANDLER,
66125
16
    ZEND_NULL_HANDLER,
66126
16
    ZEND_NULL_HANDLER,
66127
16
    ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
66128
16
    ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
66129
16
    ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
66130
16
    ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
66131
16
    ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
66132
16
    ZEND_NULL_HANDLER,
66133
16
    ZEND_NULL_HANDLER,
66134
16
    ZEND_NULL_HANDLER,
66135
16
    ZEND_NULL_HANDLER,
66136
16
    ZEND_NULL_HANDLER,
66137
16
    ZEND_NULL_HANDLER,
66138
16
    ZEND_NULL_HANDLER,
66139
16
    ZEND_NULL_HANDLER,
66140
16
    ZEND_NULL_HANDLER,
66141
16
    ZEND_NULL_HANDLER,
66142
16
    ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
66143
16
    ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
66144
16
    ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
66145
16
    ZEND_NULL_HANDLER,
66146
16
    ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
66147
16
    ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
66148
16
    ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
66149
16
    ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
66150
16
    ZEND_NULL_HANDLER,
66151
16
    ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
66152
16
    ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
66153
16
    ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
66154
16
    ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
66155
16
    ZEND_NULL_HANDLER,
66156
16
    ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
66157
16
    ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
66158
16
    ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
66159
16
    ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
66160
16
    ZEND_NULL_HANDLER,
66161
16
    ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
66162
16
    ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER,
66163
16
    ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
66164
16
    ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
66165
16
    ZEND_NULL_HANDLER,
66166
16
    ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER,
66167
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
66168
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66169
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66170
16
    ZEND_NULL_HANDLER,
66171
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
66172
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
66173
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66174
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66175
16
    ZEND_NULL_HANDLER,
66176
16
    ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
66177
16
    ZEND_NULL_HANDLER,
66178
16
    ZEND_NULL_HANDLER,
66179
16
    ZEND_NULL_HANDLER,
66180
16
    ZEND_NULL_HANDLER,
66181
16
    ZEND_NULL_HANDLER,
66182
16
    ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
66183
16
    ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
66184
16
    ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
66185
16
    ZEND_NULL_HANDLER,
66186
16
    ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
66187
16
    ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER,
66188
16
    ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
66189
16
    ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
66190
16
    ZEND_NULL_HANDLER,
66191
16
    ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER,
66192
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
66193
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66194
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66195
16
    ZEND_NULL_HANDLER,
66196
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
66197
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
66198
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66199
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66200
16
    ZEND_NULL_HANDLER,
66201
16
    ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
66202
16
    ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
66203
16
    ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
66204
16
    ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
66205
16
    ZEND_NULL_HANDLER,
66206
16
    ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
66207
16
    ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
66208
16
    ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
66209
16
    ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
66210
16
    ZEND_NULL_HANDLER,
66211
16
    ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
66212
16
    ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
66213
16
    ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
66214
16
    ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
66215
16
    ZEND_NULL_HANDLER,
66216
16
    ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
66217
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
66218
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66219
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66220
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
66221
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER,
66222
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
66223
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66224
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66225
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
66226
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER,
66227
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66228
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66229
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66230
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
66231
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
66232
16
    ZEND_NULL_HANDLER,
66233
16
    ZEND_NULL_HANDLER,
66234
16
    ZEND_NULL_HANDLER,
66235
16
    ZEND_NULL_HANDLER,
66236
16
    ZEND_NULL_HANDLER,
66237
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
66238
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66239
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66240
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
66241
16
    ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
66242
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
66243
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66244
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66245
16
    ZEND_NULL_HANDLER,
66246
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER,
66247
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
66248
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66249
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66250
16
    ZEND_NULL_HANDLER,
66251
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER,
66252
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66253
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66254
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66255
16
    ZEND_NULL_HANDLER,
66256
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
66257
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66258
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
66259
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
66260
16
    ZEND_NULL_HANDLER,
66261
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
66262
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
66263
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66264
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66265
16
    ZEND_NULL_HANDLER,
66266
16
    ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
66267
16
    ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
66268
16
    ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
66269
16
    ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
66270
16
    ZEND_NULL_HANDLER,
66271
16
    ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
66272
16
    ZEND_NULL_HANDLER,
66273
16
    ZEND_NULL_HANDLER,
66274
16
    ZEND_NULL_HANDLER,
66275
16
    ZEND_NULL_HANDLER,
66276
16
    ZEND_NULL_HANDLER,
66277
16
    ZEND_NULL_HANDLER,
66278
16
    ZEND_NULL_HANDLER,
66279
16
    ZEND_NULL_HANDLER,
66280
16
    ZEND_NULL_HANDLER,
66281
16
    ZEND_NULL_HANDLER,
66282
16
    ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
66283
16
    ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66284
16
    ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66285
16
    ZEND_NULL_HANDLER,
66286
16
    ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
66287
16
    ZEND_NULL_HANDLER,
66288
16
    ZEND_NULL_HANDLER,
66289
16
    ZEND_NULL_HANDLER,
66290
16
    ZEND_NULL_HANDLER,
66291
16
    ZEND_NULL_HANDLER,
66292
16
    ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
66293
16
    ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
66294
16
    ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
66295
16
    ZEND_NULL_HANDLER,
66296
16
    ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
66297
16
    ZEND_NULL_HANDLER,
66298
16
    ZEND_NULL_HANDLER,
66299
16
    ZEND_NULL_HANDLER,
66300
16
    ZEND_NULL_HANDLER,
66301
16
    ZEND_NULL_HANDLER,
66302
16
    ZEND_NULL_HANDLER,
66303
16
    ZEND_NULL_HANDLER,
66304
16
    ZEND_NULL_HANDLER,
66305
16
    ZEND_NULL_HANDLER,
66306
16
    ZEND_NULL_HANDLER,
66307
16
    ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
66308
16
    ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66309
16
    ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66310
16
    ZEND_NULL_HANDLER,
66311
16
    ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
66312
16
    ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
66313
16
    ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
66314
16
    ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
66315
16
    ZEND_NULL_HANDLER,
66316
16
    ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
66317
16
    ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
66318
16
    ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
66319
16
    ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
66320
16
    ZEND_NULL_HANDLER,
66321
16
    ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
66322
16
    ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER,
66323
16
    ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
66324
16
    ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
66325
16
    ZEND_NULL_HANDLER,
66326
16
    ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER,
66327
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66328
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66329
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66330
16
    ZEND_NULL_HANDLER,
66331
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66332
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66333
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66334
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66335
16
    ZEND_NULL_HANDLER,
66336
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66337
16
    ZEND_NULL_HANDLER,
66338
16
    ZEND_NULL_HANDLER,
66339
16
    ZEND_NULL_HANDLER,
66340
16
    ZEND_NULL_HANDLER,
66341
16
    ZEND_NULL_HANDLER,
66342
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66343
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66344
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66345
16
    ZEND_NULL_HANDLER,
66346
16
    ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66347
16
    ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
66348
16
    ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66349
16
    ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66350
16
    ZEND_NULL_HANDLER,
66351
16
    ZEND_NULL_HANDLER,
66352
16
    ZEND_NULL_HANDLER,
66353
16
    ZEND_NULL_HANDLER,
66354
16
    ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER,
66355
16
    ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER,
66356
16
    ZEND_NULL_HANDLER,
66357
16
    ZEND_NULL_HANDLER,
66358
16
    ZEND_EXT_STMT_SPEC_HANDLER,
66359
16
    ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
66360
16
    ZEND_EXT_FCALL_END_SPEC_HANDLER,
66361
16
    ZEND_EXT_NOP_SPEC_HANDLER,
66362
16
    ZEND_TICKS_SPEC_HANDLER,
66363
16
    ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER,
66364
16
    ZEND_NULL_HANDLER,
66365
16
    ZEND_NULL_HANDLER,
66366
16
    ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER,
66367
16
    ZEND_NULL_HANDLER,
66368
16
    ZEND_CATCH_SPEC_CONST_HANDLER,
66369
16
    ZEND_THROW_SPEC_CONST_HANDLER,
66370
16
    ZEND_THROW_SPEC_TMPVAR_HANDLER,
66371
16
    ZEND_THROW_SPEC_TMPVAR_HANDLER,
66372
16
    ZEND_NULL_HANDLER,
66373
16
    ZEND_THROW_SPEC_CV_HANDLER,
66374
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER,
66375
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
66376
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
66377
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66378
16
    ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER,
66379
16
    ZEND_CLONE_SPEC_CONST_HANDLER,
66380
16
    ZEND_CLONE_SPEC_TMPVAR_HANDLER,
66381
16
    ZEND_CLONE_SPEC_TMPVAR_HANDLER,
66382
16
    ZEND_CLONE_SPEC_UNUSED_HANDLER,
66383
16
    ZEND_CLONE_SPEC_CV_HANDLER,
66384
16
    ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
66385
16
    ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66386
16
    ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
66387
16
    ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66388
16
    ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
66389
16
    ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66390
16
    ZEND_NULL_HANDLER,
66391
16
    ZEND_NULL_HANDLER,
66392
16
    ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
66393
16
    ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66394
16
    ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
66395
16
    ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66396
16
    ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66397
16
    ZEND_NULL_HANDLER,
66398
16
    ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER,
66399
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
66400
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66401
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66402
16
    ZEND_NULL_HANDLER,
66403
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
66404
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
66405
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66406
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66407
16
    ZEND_NULL_HANDLER,
66408
16
    ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
66409
16
    ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
66410
16
    ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66411
16
    ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66412
16
    ZEND_NULL_HANDLER,
66413
16
    ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
66414
16
    ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
66415
16
    ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
66416
16
    ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
66417
16
    ZEND_NULL_HANDLER,
66418
16
    ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
66419
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
66420
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66421
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66422
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
66423
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
66424
16
    ZEND_NULL_HANDLER,
66425
16
    ZEND_NULL_HANDLER,
66426
16
    ZEND_NULL_HANDLER,
66427
16
    ZEND_NULL_HANDLER,
66428
16
    ZEND_NULL_HANDLER,
66429
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
66430
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
66431
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
66432
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
66433
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
66434
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
66435
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66436
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66437
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER,
66438
16
    ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
66439
16
    ZEND_NULL_HANDLER,
66440
16
    ZEND_NULL_HANDLER,
66441
16
    ZEND_NULL_HANDLER,
66442
16
    ZEND_NULL_HANDLER,
66443
16
    ZEND_NULL_HANDLER,
66444
16
    ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
66445
16
    ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
66446
16
    ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
66447
16
    ZEND_NULL_HANDLER,
66448
16
    ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
66449
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER,
66450
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66451
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66452
16
    ZEND_NULL_HANDLER,
66453
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER,
66454
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66455
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66456
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66457
16
    ZEND_NULL_HANDLER,
66458
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
66459
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66460
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66461
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66462
16
    ZEND_NULL_HANDLER,
66463
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
66464
16
    ZEND_NULL_HANDLER,
66465
16
    ZEND_NULL_HANDLER,
66466
16
    ZEND_NULL_HANDLER,
66467
16
    ZEND_NULL_HANDLER,
66468
16
    ZEND_NULL_HANDLER,
66469
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
66470
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
66471
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
66472
16
    ZEND_NULL_HANDLER,
66473
16
    ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
66474
16
    ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
66475
16
    ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
66476
16
    ZEND_NULL_HANDLER,
66477
16
    ZEND_NULL_HANDLER,
66478
16
    ZEND_NULL_HANDLER,
66479
16
    ZEND_NULL_HANDLER,
66480
16
    ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER,
66481
16
    ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER,
66482
16
    ZEND_NULL_HANDLER,
66483
16
    ZEND_NULL_HANDLER,
66484
16
    ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
66485
16
    ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
66486
16
    ZEND_NULL_HANDLER,
66487
16
    ZEND_NULL_HANDLER,
66488
16
    ZEND_NULL_HANDLER,
66489
16
    ZEND_NULL_HANDLER,
66490
16
    ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER,
66491
16
    ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_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_NULL_HANDLER,
66527
16
    ZEND_NULL_HANDLER,
66528
16
    ZEND_NULL_HANDLER,
66529
16
    ZEND_NULL_HANDLER,
66530
16
    ZEND_NULL_HANDLER,
66531
16
    ZEND_NULL_HANDLER,
66532
16
    ZEND_NULL_HANDLER,
66533
16
    ZEND_NULL_HANDLER,
66534
16
    ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER,
66535
16
    ZEND_NULL_HANDLER,
66536
16
    ZEND_NULL_HANDLER,
66537
16
    ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER,
66538
16
    ZEND_NULL_HANDLER,
66539
16
    ZEND_NULL_HANDLER,
66540
16
    ZEND_NULL_HANDLER,
66541
16
    ZEND_NULL_HANDLER,
66542
16
    ZEND_NULL_HANDLER,
66543
16
    ZEND_NULL_HANDLER,
66544
16
    ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER,
66545
16
    ZEND_NULL_HANDLER,
66546
16
    ZEND_NULL_HANDLER,
66547
16
    ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER,
66548
16
    ZEND_NULL_HANDLER,
66549
16
    ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER,
66550
16
    ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
66551
16
    ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
66552
16
    ZEND_NULL_HANDLER,
66553
16
    ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER,
66554
16
    ZEND_SEND_ARRAY_SPEC_HANDLER,
66555
16
    ZEND_SEND_USER_SPEC_CONST_HANDLER,
66556
16
    ZEND_SEND_USER_SPEC_TMP_HANDLER,
66557
16
    ZEND_SEND_USER_SPEC_VAR_HANDLER,
66558
16
    ZEND_NULL_HANDLER,
66559
16
    ZEND_SEND_USER_SPEC_CV_HANDLER,
66560
16
    ZEND_STRLEN_SPEC_CONST_HANDLER,
66561
16
    ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
66562
16
    ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
66563
16
    ZEND_NULL_HANDLER,
66564
16
    ZEND_STRLEN_SPEC_CV_HANDLER,
66565
16
    ZEND_DEFINED_SPEC_CONST_HANDLER,
66566
16
    ZEND_TYPE_CHECK_SPEC_CONST_HANDLER,
66567
16
    ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
66568
16
    ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
66569
16
    ZEND_NULL_HANDLER,
66570
16
    ZEND_TYPE_CHECK_SPEC_CV_HANDLER,
66571
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER,
66572
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER,
66573
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER,
66574
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
66575
16
    ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER,
66576
16
    ZEND_FE_RESET_RW_SPEC_CONST_HANDLER,
66577
16
    ZEND_FE_RESET_RW_SPEC_TMP_HANDLER,
66578
16
    ZEND_FE_RESET_RW_SPEC_VAR_HANDLER,
66579
16
    ZEND_NULL_HANDLER,
66580
16
    ZEND_FE_RESET_RW_SPEC_CV_HANDLER,
66581
16
    ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER,
66582
16
    ZEND_FE_FREE_SPEC_TMPVAR_HANDLER,
66583
16
    ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER,
66584
16
    ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
66585
16
    ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
66586
16
    ZEND_NULL_HANDLER,
66587
16
    ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER,
66588
16
    ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER,
66589
16
    ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER,
66590
16
    ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
66591
16
    ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
66592
16
    ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER,
66593
16
    ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER,
66594
16
    ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
66595
16
    ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
66596
16
    ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER,
66597
16
    ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER,
66598
16
    ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
66599
16
    ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
66600
16
    ZEND_NULL_HANDLER,
66601
16
    ZEND_NULL_HANDLER,
66602
16
    ZEND_NULL_HANDLER,
66603
16
    ZEND_NULL_HANDLER,
66604
16
    ZEND_NULL_HANDLER,
66605
16
    ZEND_NULL_HANDLER,
66606
16
    ZEND_NULL_HANDLER,
66607
16
    ZEND_NULL_HANDLER,
66608
16
    ZEND_NULL_HANDLER,
66609
16
    ZEND_NULL_HANDLER,
66610
16
    ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
66611
16
    ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66612
16
    ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66613
16
    ZEND_NULL_HANDLER,
66614
16
    ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
66615
16
    ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
66616
16
    ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66617
16
    ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66618
16
    ZEND_NULL_HANDLER,
66619
16
    ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
66620
16
    ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
66621
16
    ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66622
16
    ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66623
16
    ZEND_NULL_HANDLER,
66624
16
    ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
66625
16
    ZEND_NULL_HANDLER,
66626
16
    ZEND_NULL_HANDLER,
66627
16
    ZEND_NULL_HANDLER,
66628
16
    ZEND_NULL_HANDLER,
66629
16
    ZEND_NULL_HANDLER,
66630
16
    ZEND_NULL_HANDLER,
66631
16
    ZEND_NULL_HANDLER,
66632
16
    ZEND_NULL_HANDLER,
66633
16
    ZEND_NULL_HANDLER,
66634
16
    ZEND_NULL_HANDLER,
66635
16
    ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
66636
16
    ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66637
16
    ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66638
16
    ZEND_NULL_HANDLER,
66639
16
    ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
66640
16
    ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
66641
16
    ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66642
16
    ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66643
16
    ZEND_NULL_HANDLER,
66644
16
    ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
66645
16
    ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
66646
16
    ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66647
16
    ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66648
16
    ZEND_NULL_HANDLER,
66649
16
    ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
66650
16
    ZEND_ECHO_SPEC_CONST_HANDLER,
66651
16
    ZEND_ECHO_SPEC_TMPVAR_HANDLER,
66652
16
    ZEND_ECHO_SPEC_TMPVAR_HANDLER,
66653
16
    ZEND_NULL_HANDLER,
66654
16
    ZEND_ECHO_SPEC_CV_HANDLER,
66655
16
    ZEND_NULL_HANDLER,
66656
16
    ZEND_NULL_HANDLER,
66657
16
    ZEND_NULL_HANDLER,
66658
16
    ZEND_NULL_HANDLER,
66659
16
    ZEND_NULL_HANDLER,
66660
16
    ZEND_NULL_HANDLER,
66661
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
66662
16
    ZEND_NULL_HANDLER,
66663
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
66664
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
66665
16
    ZEND_NULL_HANDLER,
66666
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
66667
16
    ZEND_NULL_HANDLER,
66668
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
66669
16
    ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
66670
16
    ZEND_NULL_HANDLER,
66671
16
    ZEND_NULL_HANDLER,
66672
16
    ZEND_NULL_HANDLER,
66673
16
    ZEND_NULL_HANDLER,
66674
16
    ZEND_NULL_HANDLER,
66675
16
    ZEND_NULL_HANDLER,
66676
16
    ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER,
66677
16
    ZEND_NULL_HANDLER,
66678
16
    ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER,
66679
16
    ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER,
66680
16
    ZEND_NULL_HANDLER,
66681
16
    ZEND_GENERATOR_CREATE_SPEC_HANDLER,
66682
16
    ZEND_NULL_HANDLER,
66683
16
    ZEND_NULL_HANDLER,
66684
16
    ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER,
66685
16
    ZEND_NULL_HANDLER,
66686
16
    ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER,
66687
16
    ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
66688
16
    ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER,
66689
16
    ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
66690
16
    ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER,
66691
16
    ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER,
66692
16
    ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
66693
16
    ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER,
66694
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER,
66695
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66696
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66697
16
    ZEND_NULL_HANDLER,
66698
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER,
66699
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66700
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66701
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66702
16
    ZEND_NULL_HANDLER,
66703
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
66704
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66705
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66706
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66707
16
    ZEND_NULL_HANDLER,
66708
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
66709
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
66710
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66711
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66712
16
    ZEND_NULL_HANDLER,
66713
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
66714
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
66715
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
66716
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
66717
16
    ZEND_NULL_HANDLER,
66718
16
    ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
66719
16
    ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
66720
16
    ZEND_USER_OPCODE_SPEC_HANDLER,
66721
16
    ZEND_ASSERT_CHECK_SPEC_HANDLER,
66722
16
    ZEND_JMP_SET_SPEC_CONST_HANDLER,
66723
16
    ZEND_JMP_SET_SPEC_TMP_HANDLER,
66724
16
    ZEND_JMP_SET_SPEC_VAR_HANDLER,
66725
16
    ZEND_NULL_HANDLER,
66726
16
    ZEND_JMP_SET_SPEC_CV_HANDLER,
66727
16
    ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER,
66728
16
    ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER,
66729
16
    ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER,
66730
16
    ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER,
66731
16
    ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
66732
16
    ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
66733
16
    ZEND_NULL_HANDLER,
66734
16
    ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER,
66735
16
    ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
66736
16
    ZEND_NULL_HANDLER,
66737
16
    ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
66738
16
    ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
66739
16
    ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
66740
16
    ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER,
66741
16
    ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
66742
16
    ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER,
66743
16
    ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
66744
16
    ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
66745
16
    ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
66746
16
    ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
66747
16
    ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER,
66748
16
    ZEND_YIELD_SPEC_CONST_CV_HANDLER,
66749
16
    ZEND_YIELD_SPEC_TMP_CONST_HANDLER,
66750
16
    ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
66751
16
    ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
66752
16
    ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER,
66753
16
    ZEND_YIELD_SPEC_TMP_CV_HANDLER,
66754
16
    ZEND_YIELD_SPEC_VAR_CONST_HANDLER,
66755
16
    ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
66756
16
    ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
66757
16
    ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER,
66758
16
    ZEND_YIELD_SPEC_VAR_CV_HANDLER,
66759
16
    ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER,
66760
16
    ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
66761
16
    ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
66762
16
    ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER,
66763
16
    ZEND_YIELD_SPEC_UNUSED_CV_HANDLER,
66764
16
    ZEND_YIELD_SPEC_CV_CONST_HANDLER,
66765
16
    ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
66766
16
    ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
66767
16
    ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
66768
16
    ZEND_YIELD_SPEC_CV_CV_HANDLER,
66769
16
    ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER,
66770
16
    ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66771
16
    ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER,
66772
16
    ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66773
16
    ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER,
66774
16
    ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66775
16
    ZEND_NULL_HANDLER,
66776
16
    ZEND_NULL_HANDLER,
66777
16
    ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER,
66778
16
    ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66779
16
    ZEND_FAST_CALL_SPEC_HANDLER,
66780
16
    ZEND_FAST_RET_SPEC_HANDLER,
66781
16
    ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER,
66782
16
    ZEND_SEND_UNPACK_SPEC_HANDLER,
66783
16
    ZEND_YIELD_FROM_SPEC_CONST_HANDLER,
66784
16
    ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
66785
16
    ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
66786
16
    ZEND_NULL_HANDLER,
66787
16
    ZEND_YIELD_FROM_SPEC_CV_HANDLER,
66788
16
    ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER,
66789
16
    ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER,
66790
16
    ZEND_COALESCE_SPEC_CONST_HANDLER,
66791
16
    ZEND_COALESCE_SPEC_TMP_HANDLER,
66792
16
    ZEND_COALESCE_SPEC_VAR_HANDLER,
66793
16
    ZEND_NULL_HANDLER,
66794
16
    ZEND_COALESCE_SPEC_CV_HANDLER,
66795
16
    ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER,
66796
16
    ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
66797
16
    ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
66798
16
    ZEND_NULL_HANDLER,
66799
16
    ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER,
66800
16
    ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
66801
16
    ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66802
16
    ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66803
16
    ZEND_NULL_HANDLER,
66804
16
    ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
66805
16
    ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
66806
16
    ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66807
16
    ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66808
16
    ZEND_NULL_HANDLER,
66809
16
    ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
66810
16
    ZEND_NULL_HANDLER,
66811
16
    ZEND_NULL_HANDLER,
66812
16
    ZEND_NULL_HANDLER,
66813
16
    ZEND_NULL_HANDLER,
66814
16
    ZEND_NULL_HANDLER,
66815
16
    ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER,
66816
16
    ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
66817
16
    ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
66818
16
    ZEND_NULL_HANDLER,
66819
16
    ZEND_SPACESHIP_SPEC_CV_CV_HANDLER,
66820
16
    ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66821
16
    ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER,
66822
16
    ZEND_NULL_HANDLER,
66823
16
    ZEND_NULL_HANDLER,
66824
16
    ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66825
16
    ZEND_NULL_HANDLER,
66826
16
    ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER,
66827
16
    ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER,
66828
16
    ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER,
66829
16
    ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER,
66830
16
    ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER,
66831
16
    ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER,
66832
16
    ZEND_UNSET_STATIC_PROP_SPEC_HANDLER,
66833
16
    ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER,
66834
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER,
66835
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66836
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66837
16
    ZEND_NULL_HANDLER,
66838
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66839
16
    ZEND_NULL_HANDLER,
66840
16
    ZEND_NULL_HANDLER,
66841
16
    ZEND_NULL_HANDLER,
66842
16
    ZEND_NULL_HANDLER,
66843
16
    ZEND_NULL_HANDLER,
66844
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER,
66845
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66846
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66847
16
    ZEND_NULL_HANDLER,
66848
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66849
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
66850
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66851
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66852
16
    ZEND_NULL_HANDLER,
66853
16
    ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66854
16
    ZEND_NULL_HANDLER,
66855
16
    ZEND_NULL_HANDLER,
66856
16
    ZEND_NULL_HANDLER,
66857
16
    ZEND_NULL_HANDLER,
66858
16
    ZEND_NULL_HANDLER,
66859
16
    ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER,
66860
16
    ZEND_BIND_STATIC_SPEC_CV_HANDLER,
66861
16
    ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER,
66862
16
    ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66863
16
    ZEND_NULL_HANDLER,
66864
16
    ZEND_NULL_HANDLER,
66865
16
    ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
66866
16
    ZEND_NULL_HANDLER,
66867
16
    ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER,
66868
16
    ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER,
66869
16
    ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66870
16
    ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66871
16
    ZEND_NULL_HANDLER,
66872
16
    ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66873
16
    ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER,
66874
16
    ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66875
16
    ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66876
16
    ZEND_NULL_HANDLER,
66877
16
    ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66878
16
    ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER,
66879
16
    ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER,
66880
16
    ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER,
66881
16
    ZEND_NULL_HANDLER,
66882
16
    ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER,
66883
16
    ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER,
66884
16
    ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
66885
16
    ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
66886
16
    ZEND_NULL_HANDLER,
66887
16
    ZEND_COUNT_SPEC_CV_UNUSED_HANDLER,
66888
16
    ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER,
66889
16
    ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
66890
16
    ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
66891
16
    ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66892
16
    ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER,
66893
16
    ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66894
16
    ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER,
66895
16
    ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER,
66896
16
    ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER,
66897
16
    ZEND_NULL_HANDLER,
66898
16
    ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER,
66899
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER,
66900
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
66901
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
66902
16
    ZEND_NULL_HANDLER,
66903
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER,
66904
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
66905
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66906
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66907
16
    ZEND_NULL_HANDLER,
66908
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
66909
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
66910
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66911
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66912
16
    ZEND_NULL_HANDLER,
66913
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
66914
16
    ZEND_NULL_HANDLER,
66915
16
    ZEND_NULL_HANDLER,
66916
16
    ZEND_NULL_HANDLER,
66917
16
    ZEND_NULL_HANDLER,
66918
16
    ZEND_NULL_HANDLER,
66919
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER,
66920
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
66921
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
66922
16
    ZEND_NULL_HANDLER,
66923
16
    ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER,
66924
16
    ZEND_MATCH_SPEC_CONST_CONST_HANDLER,
66925
16
    ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66926
16
    ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66927
16
    ZEND_NULL_HANDLER,
66928
16
    ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66929
16
    ZEND_NULL_HANDLER,
66930
16
    ZEND_NULL_HANDLER,
66931
16
    ZEND_NULL_HANDLER,
66932
16
    ZEND_NULL_HANDLER,
66933
16
    ZEND_NULL_HANDLER,
66934
16
    ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER,
66935
16
    ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER,
66936
16
    ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER,
66937
16
    ZEND_NULL_HANDLER,
66938
16
    ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER,
66939
16
    ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER,
66940
16
    ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER,
66941
16
    ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER,
66942
16
    ZEND_NULL_HANDLER,
66943
16
    ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER,
66944
16
    ZEND_NULL_HANDLER,
66945
16
    ZEND_NULL_HANDLER,
66946
16
    ZEND_NULL_HANDLER,
66947
16
    ZEND_NULL_HANDLER,
66948
16
    ZEND_NULL_HANDLER,
66949
16
    ZEND_NULL_HANDLER,
66950
16
    ZEND_NULL_HANDLER,
66951
16
    ZEND_NULL_HANDLER,
66952
16
    ZEND_NULL_HANDLER,
66953
16
    ZEND_NULL_HANDLER,
66954
16
    ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER,
66955
16
    ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66956
16
    ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66957
16
    ZEND_NULL_HANDLER,
66958
16
    ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66959
16
    ZEND_JMP_NULL_SPEC_CONST_HANDLER,
66960
16
    ZEND_JMP_NULL_SPEC_TMP_HANDLER,
66961
16
    ZEND_JMP_NULL_SPEC_VAR_HANDLER,
66962
16
    ZEND_NULL_HANDLER,
66963
16
    ZEND_JMP_NULL_SPEC_CV_HANDLER,
66964
16
    ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66965
16
    ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER,
66966
16
    ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
66967
16
    ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER,
66968
16
    ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER,
66969
16
    ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER,
66970
16
    ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER,
66971
16
    ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER,
66972
16
    ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER,
66973
16
    ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER,
66974
16
    ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER,
66975
16
    ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER,
66976
16
    ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER,
66977
16
    ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
66978
16
    ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER,
66979
16
    ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER,
66980
16
    ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
66981
16
    ZEND_RECV_NOTYPE_SPEC_HANDLER,
66982
16
    ZEND_NULL_HANDLER,
66983
16
    ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
66984
16
    ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
66985
16
    ZEND_NULL_HANDLER,
66986
16
    ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER,
66987
16
    ZEND_JMP_FORWARD_SPEC_HANDLER,
66988
16
    ZEND_NULL_HANDLER,
66989
16
    ZEND_NULL_HANDLER,
66990
16
    ZEND_NULL_HANDLER,
66991
16
    ZEND_NULL_HANDLER,
66992
16
    ZEND_NULL_HANDLER,
66993
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66994
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66995
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66996
16
    ZEND_NULL_HANDLER,
66997
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66998
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66999
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67000
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67001
16
    ZEND_NULL_HANDLER,
67002
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67003
16
    ZEND_NULL_HANDLER,
67004
16
    ZEND_NULL_HANDLER,
67005
16
    ZEND_NULL_HANDLER,
67006
16
    ZEND_NULL_HANDLER,
67007
16
    ZEND_NULL_HANDLER,
67008
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67009
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67010
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67011
16
    ZEND_NULL_HANDLER,
67012
16
    ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67013
16
    ZEND_NULL_HANDLER,
67014
16
    ZEND_NULL_HANDLER,
67015
16
    ZEND_NULL_HANDLER,
67016
16
    ZEND_NULL_HANDLER,
67017
16
    ZEND_NULL_HANDLER,
67018
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67019
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67020
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67021
16
    ZEND_NULL_HANDLER,
67022
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67023
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67024
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67025
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67026
16
    ZEND_NULL_HANDLER,
67027
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67028
16
    ZEND_NULL_HANDLER,
67029
16
    ZEND_NULL_HANDLER,
67030
16
    ZEND_NULL_HANDLER,
67031
16
    ZEND_NULL_HANDLER,
67032
16
    ZEND_NULL_HANDLER,
67033
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67034
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67035
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67036
16
    ZEND_NULL_HANDLER,
67037
16
    ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67038
16
    ZEND_NULL_HANDLER,
67039
16
    ZEND_NULL_HANDLER,
67040
16
    ZEND_NULL_HANDLER,
67041
16
    ZEND_NULL_HANDLER,
67042
16
    ZEND_NULL_HANDLER,
67043
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67044
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67045
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67046
16
    ZEND_NULL_HANDLER,
67047
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67048
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67049
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67050
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67051
16
    ZEND_NULL_HANDLER,
67052
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67053
16
    ZEND_NULL_HANDLER,
67054
16
    ZEND_NULL_HANDLER,
67055
16
    ZEND_NULL_HANDLER,
67056
16
    ZEND_NULL_HANDLER,
67057
16
    ZEND_NULL_HANDLER,
67058
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67059
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67060
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67061
16
    ZEND_NULL_HANDLER,
67062
16
    ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67063
16
    ZEND_NULL_HANDLER,
67064
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
67065
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
67066
16
    ZEND_NULL_HANDLER,
67067
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
67068
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67069
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67070
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67071
16
    ZEND_NULL_HANDLER,
67072
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67073
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67074
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67075
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67076
16
    ZEND_NULL_HANDLER,
67077
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67078
16
    ZEND_NULL_HANDLER,
67079
16
    ZEND_NULL_HANDLER,
67080
16
    ZEND_NULL_HANDLER,
67081
16
    ZEND_NULL_HANDLER,
67082
16
    ZEND_NULL_HANDLER,
67083
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67084
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67085
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67086
16
    ZEND_NULL_HANDLER,
67087
16
    ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67088
16
    ZEND_NULL_HANDLER,
67089
16
    ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67090
16
    ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67091
16
    ZEND_NULL_HANDLER,
67092
16
    ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67093
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67094
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67095
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67096
16
    ZEND_NULL_HANDLER,
67097
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67098
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67099
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67100
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67101
16
    ZEND_NULL_HANDLER,
67102
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67103
16
    ZEND_NULL_HANDLER,
67104
16
    ZEND_NULL_HANDLER,
67105
16
    ZEND_NULL_HANDLER,
67106
16
    ZEND_NULL_HANDLER,
67107
16
    ZEND_NULL_HANDLER,
67108
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67109
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67110
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67111
16
    ZEND_NULL_HANDLER,
67112
16
    ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67113
16
    ZEND_NULL_HANDLER,
67114
16
    ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67115
16
    ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67116
16
    ZEND_NULL_HANDLER,
67117
16
    ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67118
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67119
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67120
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67121
16
    ZEND_NULL_HANDLER,
67122
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67123
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67124
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67125
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67126
16
    ZEND_NULL_HANDLER,
67127
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67128
16
    ZEND_NULL_HANDLER,
67129
16
    ZEND_NULL_HANDLER,
67130
16
    ZEND_NULL_HANDLER,
67131
16
    ZEND_NULL_HANDLER,
67132
16
    ZEND_NULL_HANDLER,
67133
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67134
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67135
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67136
16
    ZEND_NULL_HANDLER,
67137
16
    ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67138
16
    ZEND_NULL_HANDLER,
67139
16
    ZEND_NULL_HANDLER,
67140
16
    ZEND_NULL_HANDLER,
67141
16
    ZEND_NULL_HANDLER,
67142
16
    ZEND_NULL_HANDLER,
67143
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67144
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67145
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67146
16
    ZEND_NULL_HANDLER,
67147
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67148
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67149
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67150
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67151
16
    ZEND_NULL_HANDLER,
67152
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67153
16
    ZEND_NULL_HANDLER,
67154
16
    ZEND_NULL_HANDLER,
67155
16
    ZEND_NULL_HANDLER,
67156
16
    ZEND_NULL_HANDLER,
67157
16
    ZEND_NULL_HANDLER,
67158
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67159
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67160
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67161
16
    ZEND_NULL_HANDLER,
67162
16
    ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67163
16
    ZEND_NULL_HANDLER,
67164
16
    ZEND_NULL_HANDLER,
67165
16
    ZEND_NULL_HANDLER,
67166
16
    ZEND_NULL_HANDLER,
67167
16
    ZEND_NULL_HANDLER,
67168
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67169
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67170
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67171
16
    ZEND_NULL_HANDLER,
67172
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67173
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67174
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67175
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67176
16
    ZEND_NULL_HANDLER,
67177
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67178
16
    ZEND_NULL_HANDLER,
67179
16
    ZEND_NULL_HANDLER,
67180
16
    ZEND_NULL_HANDLER,
67181
16
    ZEND_NULL_HANDLER,
67182
16
    ZEND_NULL_HANDLER,
67183
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67184
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67185
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67186
16
    ZEND_NULL_HANDLER,
67187
16
    ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67188
16
    ZEND_NULL_HANDLER,
67189
16
    ZEND_NULL_HANDLER,
67190
16
    ZEND_NULL_HANDLER,
67191
16
    ZEND_NULL_HANDLER,
67192
16
    ZEND_NULL_HANDLER,
67193
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67194
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67195
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67196
16
    ZEND_NULL_HANDLER,
67197
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67198
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67199
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67200
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67201
16
    ZEND_NULL_HANDLER,
67202
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67203
16
    ZEND_NULL_HANDLER,
67204
16
    ZEND_NULL_HANDLER,
67205
16
    ZEND_NULL_HANDLER,
67206
16
    ZEND_NULL_HANDLER,
67207
16
    ZEND_NULL_HANDLER,
67208
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67209
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67210
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67211
16
    ZEND_NULL_HANDLER,
67212
16
    ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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_NULL_HANDLER,
67221
16
    ZEND_NULL_HANDLER,
67222
16
    ZEND_NULL_HANDLER,
67223
16
    ZEND_NULL_HANDLER,
67224
16
    ZEND_NULL_HANDLER,
67225
16
    ZEND_NULL_HANDLER,
67226
16
    ZEND_NULL_HANDLER,
67227
16
    ZEND_NULL_HANDLER,
67228
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67229
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67230
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67231
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67232
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67233
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67234
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67235
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67236
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67237
16
    ZEND_NULL_HANDLER,
67238
16
    ZEND_NULL_HANDLER,
67239
16
    ZEND_NULL_HANDLER,
67240
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67241
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67242
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67243
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67244
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67245
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67246
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67247
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67248
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67249
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67250
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67251
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67252
16
    ZEND_NULL_HANDLER,
67253
16
    ZEND_NULL_HANDLER,
67254
16
    ZEND_NULL_HANDLER,
67255
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67256
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67257
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67266
16
    ZEND_NULL_HANDLER,
67267
16
    ZEND_NULL_HANDLER,
67268
16
    ZEND_NULL_HANDLER,
67269
16
    ZEND_NULL_HANDLER,
67270
16
    ZEND_NULL_HANDLER,
67271
16
    ZEND_NULL_HANDLER,
67272
16
    ZEND_NULL_HANDLER,
67273
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67274
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67275
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67276
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67277
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67278
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67279
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67280
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67281
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67282
16
    ZEND_NULL_HANDLER,
67283
16
    ZEND_NULL_HANDLER,
67284
16
    ZEND_NULL_HANDLER,
67285
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67286
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67287
16
    ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67296
16
    ZEND_NULL_HANDLER,
67297
16
    ZEND_NULL_HANDLER,
67298
16
    ZEND_NULL_HANDLER,
67299
16
    ZEND_NULL_HANDLER,
67300
16
    ZEND_NULL_HANDLER,
67301
16
    ZEND_NULL_HANDLER,
67302
16
    ZEND_NULL_HANDLER,
67303
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67304
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67305
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67306
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67307
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67308
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67309
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67310
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67311
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67312
16
    ZEND_NULL_HANDLER,
67313
16
    ZEND_NULL_HANDLER,
67314
16
    ZEND_NULL_HANDLER,
67315
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67316
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67317
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67318
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67319
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67320
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67321
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67322
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67323
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67324
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67325
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67326
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67327
16
    ZEND_NULL_HANDLER,
67328
16
    ZEND_NULL_HANDLER,
67329
16
    ZEND_NULL_HANDLER,
67330
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67331
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67332
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67341
16
    ZEND_NULL_HANDLER,
67342
16
    ZEND_NULL_HANDLER,
67343
16
    ZEND_NULL_HANDLER,
67344
16
    ZEND_NULL_HANDLER,
67345
16
    ZEND_NULL_HANDLER,
67346
16
    ZEND_NULL_HANDLER,
67347
16
    ZEND_NULL_HANDLER,
67348
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67349
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67350
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67351
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67352
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67353
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67354
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67355
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67356
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67357
16
    ZEND_NULL_HANDLER,
67358
16
    ZEND_NULL_HANDLER,
67359
16
    ZEND_NULL_HANDLER,
67360
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67361
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67362
16
    ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67371
16
    ZEND_NULL_HANDLER,
67372
16
    ZEND_NULL_HANDLER,
67373
16
    ZEND_NULL_HANDLER,
67374
16
    ZEND_NULL_HANDLER,
67375
16
    ZEND_NULL_HANDLER,
67376
16
    ZEND_NULL_HANDLER,
67377
16
    ZEND_NULL_HANDLER,
67378
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67379
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67380
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67381
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67382
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67383
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67384
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67385
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67386
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67387
16
    ZEND_NULL_HANDLER,
67388
16
    ZEND_NULL_HANDLER,
67389
16
    ZEND_NULL_HANDLER,
67390
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67391
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67392
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67393
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67394
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67395
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67396
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67397
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67398
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67399
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67400
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67401
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67402
16
    ZEND_NULL_HANDLER,
67403
16
    ZEND_NULL_HANDLER,
67404
16
    ZEND_NULL_HANDLER,
67405
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67406
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67407
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67416
16
    ZEND_NULL_HANDLER,
67417
16
    ZEND_NULL_HANDLER,
67418
16
    ZEND_NULL_HANDLER,
67419
16
    ZEND_NULL_HANDLER,
67420
16
    ZEND_NULL_HANDLER,
67421
16
    ZEND_NULL_HANDLER,
67422
16
    ZEND_NULL_HANDLER,
67423
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67424
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67425
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67426
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67427
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67428
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67429
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67430
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67431
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67432
16
    ZEND_NULL_HANDLER,
67433
16
    ZEND_NULL_HANDLER,
67434
16
    ZEND_NULL_HANDLER,
67435
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67436
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67437
16
    ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67446
16
    ZEND_NULL_HANDLER,
67447
16
    ZEND_NULL_HANDLER,
67448
16
    ZEND_NULL_HANDLER,
67449
16
    ZEND_NULL_HANDLER,
67450
16
    ZEND_NULL_HANDLER,
67451
16
    ZEND_NULL_HANDLER,
67452
16
    ZEND_NULL_HANDLER,
67453
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67454
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67455
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67456
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67457
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67458
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67459
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67460
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67461
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67462
16
    ZEND_NULL_HANDLER,
67463
16
    ZEND_NULL_HANDLER,
67464
16
    ZEND_NULL_HANDLER,
67465
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67466
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67467
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67468
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67469
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67470
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67471
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67472
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67473
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67474
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67475
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67476
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67477
16
    ZEND_NULL_HANDLER,
67478
16
    ZEND_NULL_HANDLER,
67479
16
    ZEND_NULL_HANDLER,
67480
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67481
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67482
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67491
16
    ZEND_NULL_HANDLER,
67492
16
    ZEND_NULL_HANDLER,
67493
16
    ZEND_NULL_HANDLER,
67494
16
    ZEND_NULL_HANDLER,
67495
16
    ZEND_NULL_HANDLER,
67496
16
    ZEND_NULL_HANDLER,
67497
16
    ZEND_NULL_HANDLER,
67498
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67499
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67500
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67501
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67502
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67503
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67504
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67505
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67506
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67507
16
    ZEND_NULL_HANDLER,
67508
16
    ZEND_NULL_HANDLER,
67509
16
    ZEND_NULL_HANDLER,
67510
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67511
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67512
16
    ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67513
16
    ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER,
67514
16
    ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67515
16
    ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67516
16
    ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_HANDLER,
67517
16
    ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67518
16
    ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67519
16
    ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
67520
16
    ZEND_NULL_HANDLER,
67521
16
    ZEND_NULL_HANDLER,
67522
16
    ZEND_NULL_HANDLER,
67523
16
    ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
67524
16
    ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
67525
16
    ZEND_NULL_HANDLER,
67526
16
    ZEND_NULL_HANDLER,
67527
16
    ZEND_NULL_HANDLER,
67528
16
    ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
67529
16
    ZEND_NULL_HANDLER,
67530
16
    ZEND_NULL_HANDLER,
67531
16
    ZEND_NULL_HANDLER,
67532
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67533
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67534
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67535
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67536
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67537
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67538
16
    ZEND_NULL_HANDLER,
67539
16
    ZEND_NULL_HANDLER,
67540
16
    ZEND_NULL_HANDLER,
67541
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67542
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67543
16
    ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67544
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67545
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67546
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67547
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67548
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67549
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67550
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67551
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67552
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67553
16
    ZEND_NULL_HANDLER,
67554
16
    ZEND_NULL_HANDLER,
67555
16
    ZEND_NULL_HANDLER,
67556
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67557
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67558
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67559
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67560
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67561
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67562
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67563
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67564
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67565
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67566
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67567
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67568
16
    ZEND_NULL_HANDLER,
67569
16
    ZEND_NULL_HANDLER,
67570
16
    ZEND_NULL_HANDLER,
67571
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67572
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67573
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67582
16
    ZEND_NULL_HANDLER,
67583
16
    ZEND_NULL_HANDLER,
67584
16
    ZEND_NULL_HANDLER,
67585
16
    ZEND_NULL_HANDLER,
67586
16
    ZEND_NULL_HANDLER,
67587
16
    ZEND_NULL_HANDLER,
67588
16
    ZEND_NULL_HANDLER,
67589
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67590
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67591
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67592
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67593
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67594
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67595
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67596
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67597
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67598
16
    ZEND_NULL_HANDLER,
67599
16
    ZEND_NULL_HANDLER,
67600
16
    ZEND_NULL_HANDLER,
67601
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67602
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67603
16
    ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67604
16
    ZEND_NULL_HANDLER,
67605
16
    ZEND_NULL_HANDLER,
67606
16
    ZEND_NULL_HANDLER,
67607
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67608
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67609
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67610
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67611
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67612
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67613
16
    ZEND_NULL_HANDLER,
67614
16
    ZEND_NULL_HANDLER,
67615
16
    ZEND_NULL_HANDLER,
67616
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67617
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67618
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67619
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67620
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67621
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67622
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67623
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67624
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67625
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67626
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67627
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67628
16
    ZEND_NULL_HANDLER,
67629
16
    ZEND_NULL_HANDLER,
67630
16
    ZEND_NULL_HANDLER,
67631
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67632
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67633
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67634
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67635
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67636
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67637
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67638
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67639
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67640
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67641
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67642
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67643
16
    ZEND_NULL_HANDLER,
67644
16
    ZEND_NULL_HANDLER,
67645
16
    ZEND_NULL_HANDLER,
67646
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67647
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67648
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67657
16
    ZEND_NULL_HANDLER,
67658
16
    ZEND_NULL_HANDLER,
67659
16
    ZEND_NULL_HANDLER,
67660
16
    ZEND_NULL_HANDLER,
67661
16
    ZEND_NULL_HANDLER,
67662
16
    ZEND_NULL_HANDLER,
67663
16
    ZEND_NULL_HANDLER,
67664
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67665
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67666
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67667
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67668
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67669
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67670
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67671
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67672
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67673
16
    ZEND_NULL_HANDLER,
67674
16
    ZEND_NULL_HANDLER,
67675
16
    ZEND_NULL_HANDLER,
67676
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67677
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67678
16
    ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67679
16
    ZEND_NULL_HANDLER,
67680
16
    ZEND_NULL_HANDLER,
67681
16
    ZEND_NULL_HANDLER,
67682
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67683
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67684
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67685
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67686
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67687
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67688
16
    ZEND_NULL_HANDLER,
67689
16
    ZEND_NULL_HANDLER,
67690
16
    ZEND_NULL_HANDLER,
67691
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67692
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67693
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67694
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67695
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67696
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67697
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67698
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67699
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67700
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67701
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67702
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67703
16
    ZEND_NULL_HANDLER,
67704
16
    ZEND_NULL_HANDLER,
67705
16
    ZEND_NULL_HANDLER,
67706
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67707
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67708
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67709
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67710
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67711
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67712
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67713
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67714
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67715
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67716
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67717
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67718
16
    ZEND_NULL_HANDLER,
67719
16
    ZEND_NULL_HANDLER,
67720
16
    ZEND_NULL_HANDLER,
67721
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67722
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67723
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67732
16
    ZEND_NULL_HANDLER,
67733
16
    ZEND_NULL_HANDLER,
67734
16
    ZEND_NULL_HANDLER,
67735
16
    ZEND_NULL_HANDLER,
67736
16
    ZEND_NULL_HANDLER,
67737
16
    ZEND_NULL_HANDLER,
67738
16
    ZEND_NULL_HANDLER,
67739
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67740
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67741
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67742
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67743
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67744
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67745
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67746
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67747
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67748
16
    ZEND_NULL_HANDLER,
67749
16
    ZEND_NULL_HANDLER,
67750
16
    ZEND_NULL_HANDLER,
67751
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67752
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67753
16
    ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67754
16
    ZEND_NULL_HANDLER,
67755
16
    ZEND_NULL_HANDLER,
67756
16
    ZEND_NULL_HANDLER,
67757
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67758
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67759
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67760
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67761
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67762
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67763
16
    ZEND_NULL_HANDLER,
67764
16
    ZEND_NULL_HANDLER,
67765
16
    ZEND_NULL_HANDLER,
67766
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67767
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67768
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67769
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67770
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67771
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67772
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67773
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67774
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67775
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67776
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67777
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67778
16
    ZEND_NULL_HANDLER,
67779
16
    ZEND_NULL_HANDLER,
67780
16
    ZEND_NULL_HANDLER,
67781
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67782
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67783
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67784
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67785
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67786
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67787
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67788
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67789
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67790
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67791
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67792
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67793
16
    ZEND_NULL_HANDLER,
67794
16
    ZEND_NULL_HANDLER,
67795
16
    ZEND_NULL_HANDLER,
67796
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67797
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67798
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
67807
16
    ZEND_NULL_HANDLER,
67808
16
    ZEND_NULL_HANDLER,
67809
16
    ZEND_NULL_HANDLER,
67810
16
    ZEND_NULL_HANDLER,
67811
16
    ZEND_NULL_HANDLER,
67812
16
    ZEND_NULL_HANDLER,
67813
16
    ZEND_NULL_HANDLER,
67814
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67815
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67816
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67817
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67818
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67819
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67820
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67821
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67822
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67823
16
    ZEND_NULL_HANDLER,
67824
16
    ZEND_NULL_HANDLER,
67825
16
    ZEND_NULL_HANDLER,
67826
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67827
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67828
16
    ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67829
16
    ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
67830
16
    ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
67831
16
    ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
67832
16
    ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
67833
16
    ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
67834
16
    ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
67835
16
    ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
67836
16
    ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
67837
16
    ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
67838
16
    ZEND_POST_INC_LONG_SPEC_CV_HANDLER,
67839
16
    ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
67840
16
    ZEND_POST_DEC_LONG_SPEC_CV_HANDLER,
67841
16
    ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER,
67842
16
    ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67843
16
    ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67844
16
    ZEND_NULL_HANDLER,
67845
16
    ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67846
16
    ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER,
67847
16
    ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67848
16
    ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67849
16
    ZEND_NULL_HANDLER,
67850
16
    ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67851
16
    ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER,
67852
16
    ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67853
16
    ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67854
16
    ZEND_NULL_HANDLER,
67855
16
    ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67856
16
    ZEND_NULL_HANDLER,
67857
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67858
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67859
16
    ZEND_NULL_HANDLER,
67860
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67861
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
67862
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67863
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67864
16
    ZEND_NULL_HANDLER,
67865
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67866
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
67867
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67868
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67869
16
    ZEND_NULL_HANDLER,
67870
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67871
16
    ZEND_NULL_HANDLER,
67872
16
    ZEND_NULL_HANDLER,
67873
16
    ZEND_NULL_HANDLER,
67874
16
    ZEND_NULL_HANDLER,
67875
16
    ZEND_NULL_HANDLER,
67876
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER,
67877
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67878
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67879
16
    ZEND_NULL_HANDLER,
67880
16
    ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67881
16
    ZEND_NULL_HANDLER,
67882
16
    ZEND_NULL_HANDLER,
67883
16
    ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER,
67884
16
    ZEND_NULL_HANDLER,
67885
16
    ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER,
67886
16
    ZEND_NULL_HANDLER,
67887
16
    ZEND_NULL_HANDLER,
67888
16
    ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER,
67889
16
    ZEND_NULL_HANDLER,
67890
16
    ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER,
67891
16
    ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER,
67892
16
    ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER,
67893
16
    ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
67894
16
    ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER,
67895
16
    ZEND_NULL_HANDLER
67896
16
  };
67897
16
  static const uint32_t specs[] = {
67898
16
    0,
67899
16
    1 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67900
16
    26 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67901
16
    51 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67902
16
    76 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67903
16
    101 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67904
16
    126 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67905
16
    151 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67906
16
    176 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67907
16
    201 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67908
16
    226 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67909
16
    251 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67910
16
    276 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67911
16
    301 | SPEC_RULE_OP1,
67912
16
    306 | SPEC_RULE_OP1,
67913
16
    311 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67914
16
    336 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67915
16
    361 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67916
16
    386 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
67917
16
    461 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
67918
16
    536 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
67919
16
    611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
67920
16
    686 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL,
67921
16
    736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67922
16
    861 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67923
16
    986 | SPEC_RULE_OP_DATA,
67924
16
    991 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67925
16
    1016 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67926
16
    1041 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67927
16
    1066,
67928
16
    1067 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67929
16
    1092 | SPEC_RULE_OP1,
67930
16
    1097 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67931
16
    1222,
67932
16
    1223 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
67933
16
    1233 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
67934
16
    1243 | SPEC_RULE_OP1,
67935
16
    1248 | SPEC_RULE_OP1,
67936
16
    1253,
67937
16
    1253,
67938
16
    1254,
67939
16
    1254,
67940
16
    1255,
67941
16
    1256 | SPEC_RULE_OP1,
67942
16
    1261 | SPEC_RULE_OP1,
67943
16
    3493,
67944
16
    1266 | SPEC_RULE_OP1,
67945
16
    1271 | SPEC_RULE_OP1,
67946
16
    1276 | SPEC_RULE_OP2,
67947
16
    1281,
67948
16
    1282 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67949
16
    1292 | SPEC_RULE_OP1,
67950
16
    1297 | SPEC_RULE_OP1,
67951
16
    1302 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67952
16
    1327 | SPEC_RULE_OP2,
67953
16
    1332 | SPEC_RULE_OP2,
67954
16
    1337 | SPEC_RULE_OP2,
67955
16
    1342,
67956
16
    1343,
67957
16
    1344,
67958
16
    1345 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67959
16
    1349,
67960
16
    1350 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67961
16
    1360,
67962
16
    1361,
67963
16
    1362 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67964
16
    1387 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67965
16
    1437 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67966
16
    1462 | SPEC_RULE_OP1,
67967
16
    1467,
67968
16
    1468,
67969
16
    1469 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67970
16
    1494 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67971
16
    1519 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67972
16
    1529 | SPEC_RULE_OP1,
67973
16
    1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67974
16
    1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67975
16
    1584 | SPEC_RULE_OP1,
67976
16
    1589,
67977
16
    3493,
67978
16
    1590 | SPEC_RULE_OP1,
67979
16
    1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67980
16
    1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67981
16
    1645 | SPEC_RULE_OP1,
67982
16
    1650 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67983
16
    1675 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67984
16
    1700 | SPEC_RULE_OP1,
67985
16
    1705 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67986
16
    1730 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67987
16
    1755 | SPEC_RULE_OP1,
67988
16
    1760 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67989
16
    1785 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67990
16
    1810 | SPEC_RULE_OP1,
67991
16
    1815 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67992
16
    1840 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67993
16
    1865 | SPEC_RULE_OP1,
67994
16
    1870 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67995
16
    1895 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67996
16
    1920 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67997
16
    1945,
67998
16
    1946 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67999
16
    1956,
68000
16
    1957,
68001
16
    1958,
68002
16
    1959,
68003
16
    1960,
68004
16
    1961 | SPEC_RULE_OP2,
68005
16
    1966,
68006
16
    1967 | SPEC_RULE_OP1,
68007
16
    1972 | SPEC_RULE_OP2,
68008
16
    1977 | SPEC_RULE_OP1,
68009
16
    1982 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
68010
16
    1992 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68011
16
    2017 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68012
16
    2042 | SPEC_RULE_OP1,
68013
16
    2047 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68014
16
    2072 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
68015
16
    2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68016
16
    2147 | SPEC_RULE_OP2,
68017
16
    2152,
68018
16
    2153 | SPEC_RULE_OP1,
68019
16
    2158 | SPEC_RULE_OP1,
68020
16
    2163,
68021
16
    2164 | SPEC_RULE_OP1,
68022
16
    2169 | SPEC_RULE_OP1,
68023
16
    2174 | SPEC_RULE_OP1,
68024
16
    2179,
68025
16
    2180,
68026
16
    2181 | SPEC_RULE_OP2,
68027
16
    2186 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
68028
16
    2190 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
68029
16
    2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
68030
16
    2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68031
16
    2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68032
16
    2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68033
16
    2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68034
16
    2248 | SPEC_RULE_OP1,
68035
16
    2253,
68036
16
    2254 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68037
16
    2279,
68038
16
    2280 | SPEC_RULE_OP1,
68039
16
    2285,
68040
16
    2286,
68041
16
    2287,
68042
16
    2288,
68043
16
    2289,
68044
16
    2290,
68045
16
    2291,
68046
16
    2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68047
16
    2317,
68048
16
    2318,
68049
16
    2319,
68050
16
    2320 | SPEC_RULE_OP1,
68051
16
    2325,
68052
16
    2326 | SPEC_RULE_ISSET,
68053
16
    2328 | SPEC_RULE_OP2,
68054
16
    2333,
68055
16
    2334 | SPEC_RULE_OP1,
68056
16
    2339 | SPEC_RULE_OBSERVER,
68057
16
    2341,
68058
16
    2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68059
16
    2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
68060
16
    2377,
68061
16
    2378,
68062
16
    2379,
68063
16
    2380,
68064
16
    2381 | SPEC_RULE_OP1,
68065
16
    2386,
68066
16
    2387,
68067
16
    2388 | SPEC_RULE_OP1,
68068
16
    2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68069
16
    2418,
68070
16
    2419 | SPEC_RULE_OP1,
68071
16
    2424,
68072
16
    2425,
68073
16
    2426,
68074
16
    2427,
68075
16
    2428,
68076
16
    2429,
68077
16
    2430,
68078
16
    2431,
68079
16
    2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68080
16
    2457,
68081
16
    2458,
68082
16
    2459,
68083
16
    2460 | SPEC_RULE_OP2,
68084
16
    2465,
68085
16
    2466 | SPEC_RULE_OP1,
68086
16
    2471 | SPEC_RULE_OP1,
68087
16
    2476 | SPEC_RULE_OP1,
68088
16
    2481 | SPEC_RULE_OP1,
68089
16
    2486 | SPEC_RULE_OP1,
68090
16
    2491,
68091
16
    2492 | SPEC_RULE_OP1,
68092
16
    2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68093
16
    2522 | SPEC_RULE_OP1,
68094
16
    2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
68095
16
    2552 | SPEC_RULE_OP1,
68096
16
    2557 | SPEC_RULE_OP1,
68097
16
    2562,
68098
16
    2563,
68099
16
    2564,
68100
16
    2565,
68101
16
    2566,
68102
16
    2567 | SPEC_RULE_OBSERVER,
68103
16
    2569 | SPEC_RULE_OBSERVER,
68104
16
    2571 | SPEC_RULE_OBSERVER,
68105
16
    2573 | SPEC_RULE_OBSERVER,
68106
16
    2575,
68107
16
    2576,
68108
16
    2577,
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
    3493,
68147
16
    3493,
68148
16
    3493,
68149
16
    3493,
68150
16
    3493,
68151
16
    3493,
68152
16
    3493,
68153
16
    3493,
68154
16
  };
68155
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68156
  zend_opcode_handler_funcs = labels;
68157
  zend_spec_handlers = specs;
68158
  execute_ex(NULL);
68159
#else
68160
16
  zend_opcode_handlers = labels;
68161
16
  zend_handlers_count = sizeof(labels) / sizeof(void*);
68162
16
  zend_spec_handlers = specs;
68163
16
#endif
68164
16
  VM_TRACE_START();
68165
16
}
68166
68167
static HashTable *zend_handlers_table = NULL;
68168
68169
void zend_vm_dtor(void)
68170
0
{
68171
0
  VM_TRACE_END();
68172
0
  if (zend_handlers_table) {
68173
0
    zend_hash_destroy(zend_handlers_table);
68174
0
    free(zend_handlers_table);
68175
0
    zend_handlers_table = NULL;
68176
0
  }
68177
0
}
68178
68179
static void init_opcode_serialiser(void)
68180
0
{
68181
0
  int i;
68182
0
  zval tmp;
68183
68184
0
  zend_handlers_table = malloc(sizeof(HashTable));
68185
0
  zend_hash_init(zend_handlers_table, zend_handlers_count, NULL, NULL, 1);
68186
0
  zend_hash_real_init(zend_handlers_table, 0);
68187
0
  Z_TYPE_INFO(tmp) = IS_LONG;
68188
0
  for (i = 0; i < zend_handlers_count; i++) {
68189
0
    Z_LVAL(tmp) = i;
68190
0
    zend_hash_index_add(zend_handlers_table, (zend_long)(uintptr_t)zend_opcode_handlers[i], &tmp);
68191
0
  }
68192
0
}
68193
68194
ZEND_API void ZEND_FASTCALL zend_serialize_opcode_handler(zend_op *op)
68195
0
{
68196
0
  zval *zv;
68197
68198
0
  if (!zend_handlers_table) {
68199
0
    init_opcode_serialiser();
68200
0
  }
68201
0
  zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
68202
0
  ZEND_ASSERT(zv != NULL);
68203
0
  op->handler = (const void *)(uintptr_t)Z_LVAL_P(zv);
68204
0
}
68205
68206
ZEND_API void ZEND_FASTCALL zend_deserialize_opcode_handler(zend_op *op)
68207
0
{
68208
0
  op->handler = zend_opcode_handlers[(uintptr_t)op->handler];
68209
0
}
68210
68211
ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *op)
68212
0
{
68213
0
#if ZEND_VM_KIND == ZEND_VM_KIND_CALL
68214
0
  return op->handler;
68215
#elif ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68216
  zval *zv;
68217
68218
  if (!zend_handlers_table) {
68219
    init_opcode_serialiser();
68220
  }
68221
  zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
68222
  ZEND_ASSERT(zv != NULL);
68223
  return zend_opcode_handler_funcs[Z_LVAL_P(zv)];
68224
#else
68225
  return NULL;
68226
#endif
68227
0
}
68228
68229
ZEND_API const zend_op *zend_get_halt_op(void)
68230
0
{
68231
#if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68232
  return &hybrid_halt_op;
68233
#else
68234
0
  return NULL;
68235
0
#endif
68236
0
}
68237
68238
ZEND_API int zend_vm_kind(void)
68239
0
{
68240
0
  return ZEND_VM_KIND;
68241
0
}
68242
68243
static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, const zend_op* op)
68244
13.5M
{
68245
13.5M
  static const int zend_vm_decode[] = {
68246
13.5M
    _UNUSED_CODE, /* 0 = IS_UNUSED  */
68247
13.5M
    _CONST_CODE,  /* 1 = IS_CONST   */
68248
13.5M
    _TMP_CODE,    /* 2 = IS_TMP_VAR */
68249
13.5M
    _UNUSED_CODE, /* 3              */
68250
13.5M
    _VAR_CODE,    /* 4 = IS_VAR     */
68251
13.5M
    _UNUSED_CODE, /* 5              */
68252
13.5M
    _UNUSED_CODE, /* 6              */
68253
13.5M
    _UNUSED_CODE, /* 7              */
68254
13.5M
    _CV_CODE      /* 8 = IS_CV      */
68255
13.5M
  };
68256
13.5M
  uint32_t offset = 0;
68257
13.5M
  if (spec & SPEC_RULE_OP1) offset = offset * 5 + zend_vm_decode[op->op1_type];
68258
13.5M
  if (spec & SPEC_RULE_OP2) offset = offset * 5 + zend_vm_decode[op->op2_type];
68259
13.5M
  if (spec & SPEC_EXTRA_MASK) {
68260
2.60M
    if (spec & SPEC_RULE_RETVAL) {
68261
1.24M
      offset = offset * 2 + (op->result_type != IS_UNUSED);
68262
1.24M
      if ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {
68263
0
        offset += 2;
68264
0
      }
68265
1.36M
    } else if (spec & SPEC_RULE_QUICK_ARG) {
68266
518k
      offset = offset * 2 + (op->op2.num <= MAX_ARG_FLAG_NUM);
68267
846k
    } else if (spec & SPEC_RULE_OP_DATA) {
68268
55.0k
      offset = offset * 5 + zend_vm_decode[(op + 1)->op1_type];
68269
791k
    } else if (spec & SPEC_RULE_ISSET) {
68270
903
      offset = offset * 2 + (op->extended_value & ZEND_ISEMPTY);
68271
790k
    } else if (spec & SPEC_RULE_SMART_BRANCH) {
68272
170k
      offset = offset * 3;
68273
170k
      if (op->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR)) {
68274
30.0k
        offset += 1;
68275
140k
      } else if (op->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) {
68276
23.3k
        offset += 2;
68277
23.3k
      }
68278
619k
    } else if (spec & SPEC_RULE_OBSERVER) {
68279
465k
      offset = offset * 2;
68280
465k
      if (ZEND_OBSERVER_ENABLED) {
68281
0
        offset += 1;
68282
0
      }
68283
465k
    }
68284
2.60M
  }
68285
13.5M
  return (spec & SPEC_START_MASK) + offset;
68286
13.5M
}
68287
68288
#if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
68289
static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op)
68290
0
{
68291
0
  return zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
68292
0
}
68293
#endif
68294
68295
#if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68296
static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op* op)
68297
{
68298
  uint32_t spec = zend_spec_handlers[opcode];
68299
  return zend_opcode_handler_funcs[zend_vm_get_opcode_handler_idx(spec, op)];
68300
}
68301
68302
#endif
68303
68304
ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler(zend_op* op)
68305
11.7M
{
68306
11.7M
  uint8_t opcode = zend_user_opcodes[op->opcode];
68307
68308
11.7M
  if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
68309
229k
    if (op->op1_type < op->op2_type) {
68310
25.9k
      zend_swap_operands(op);
68311
25.9k
    }
68312
229k
  }
68313
11.7M
  op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
68314
11.7M
}
68315
68316
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)
68317
1.79M
{
68318
1.79M
  uint8_t opcode = zend_user_opcodes[op->opcode];
68319
1.79M
  uint32_t spec = zend_spec_handlers[opcode];
68320
1.79M
  switch (opcode) {
68321
11.2k
    case ZEND_ADD:
68322
11.2k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68323
304
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68324
4
          break;
68325
4
        }
68326
300
        spec = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68327
300
        if (op->op1_type < op->op2_type) {
68328
17
          zend_swap_operands(op);
68329
17
        }
68330
10.9k
      } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68331
260
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68332
0
          break;
68333
0
        }
68334
260
        spec = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68335
260
        if (op->op1_type < op->op2_type) {
68336
17
          zend_swap_operands(op);
68337
17
        }
68338
10.7k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68339
63
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68340
0
          break;
68341
0
        }
68342
63
        spec = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68343
63
        if (op->op1_type < op->op2_type) {
68344
0
          zend_swap_operands(op);
68345
0
        }
68346
63
      }
68347
11.2k
      break;
68348
11.4k
    case ZEND_SUB:
68349
11.4k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68350
340
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68351
0
          break;
68352
0
        }
68353
340
        spec = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68354
11.1k
      } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68355
222
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68356
0
          break;
68357
0
        }
68358
222
        spec = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68359
10.8k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68360
24
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68361
0
          break;
68362
0
        }
68363
24
        spec = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68364
24
      }
68365
11.4k
      break;
68366
11.4k
    case ZEND_MUL:
68367
7.70k
      if (op->op1_type < op->op2_type) {
68368
12
        zend_swap_operands(op);
68369
12
      }
68370
7.70k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68371
32
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68372
0
          break;
68373
0
        }
68374
32
        spec = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68375
7.67k
      } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68376
191
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68377
0
          break;
68378
0
        }
68379
191
        spec = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68380
7.47k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68381
36
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68382
0
          break;
68383
0
        }
68384
36
        spec = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68385
36
      }
68386
7.70k
      break;
68387
7.70k
    case ZEND_IS_IDENTICAL:
68388
1.81k
      if (op->op1_type < op->op2_type) {
68389
4
        zend_swap_operands(op);
68390
4
      }
68391
1.81k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68392
168
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68393
0
          break;
68394
0
        }
68395
168
        spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68396
1.65k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68397
83
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68398
0
          break;
68399
0
        }
68400
83
        spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68401
1.56k
      } 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)) {
68402
0
        spec = 3111 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68403
1.56k
      } 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))) {
68404
259
        spec = 3117 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68405
259
      }
68406
1.81k
      break;
68407
1.81k
    case ZEND_IS_NOT_IDENTICAL:
68408
572
      if (op->op1_type < op->op2_type) {
68409
18
        zend_swap_operands(op);
68410
18
      }
68411
572
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68412
10
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68413
0
          break;
68414
0
        }
68415
10
        spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68416
562
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68417
64
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68418
0
          break;
68419
0
        }
68420
64
        spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68421
498
      } 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)) {
68422
0
        spec = 3114 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68423
498
      } 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))) {
68424
28
        spec = 3122 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68425
28
      }
68426
572
      break;
68427
2.93k
    case ZEND_IS_EQUAL:
68428
2.93k
      if (op->op1_type < op->op2_type) {
68429
5
        zend_swap_operands(op);
68430
5
      }
68431
2.93k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68432
195
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68433
0
          break;
68434
0
        }
68435
195
        spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68436
2.73k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68437
140
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68438
0
          break;
68439
0
        }
68440
140
        spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68441
140
      }
68442
2.93k
      break;
68443
2.93k
    case ZEND_IS_NOT_EQUAL:
68444
1.84k
      if (op->op1_type < op->op2_type) {
68445
65
        zend_swap_operands(op);
68446
65
      }
68447
1.84k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68448
22
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68449
0
          break;
68450
0
        }
68451
22
        spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68452
1.81k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68453
102
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68454
0
          break;
68455
0
        }
68456
102
        spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68457
102
      }
68458
1.84k
      break;
68459
8.97k
    case ZEND_IS_SMALLER:
68460
8.97k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68461
1.11k
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68462
2
          break;
68463
2
        }
68464
1.10k
        spec = 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68465
7.85k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68466
57
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68467
0
          break;
68468
0
        }
68469
57
        spec = 3202 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68470
57
      }
68471
8.96k
      break;
68472
8.96k
    case ZEND_IS_SMALLER_OR_EQUAL:
68473
1.98k
      if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68474
329
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68475
0
          break;
68476
0
        }
68477
329
        spec = 3277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68478
1.65k
      } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68479
0
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68480
0
          break;
68481
0
        }
68482
0
        spec = 3352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68483
0
      }
68484
1.98k
      break;
68485
21.5k
    case ZEND_QM_ASSIGN:
68486
21.5k
      if (op1_info == MAY_BE_LONG) {
68487
3.91k
        spec = 3439 | SPEC_RULE_OP1;
68488
17.6k
      } else if (op1_info == MAY_BE_DOUBLE) {
68489
114
        spec = 3444 | SPEC_RULE_OP1;
68490
17.5k
      } 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))))) {
68491
12.1k
        spec = 3449 | SPEC_RULE_OP1;
68492
12.1k
      }
68493
21.5k
      break;
68494
4.01k
    case ZEND_PRE_INC:
68495
4.01k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68496
925
        spec = 3427 | SPEC_RULE_RETVAL;
68497
3.09k
      } else if (op1_info == MAY_BE_LONG) {
68498
12
        spec = 3429 | SPEC_RULE_RETVAL;
68499
12
      }
68500
4.01k
      break;
68501
509
    case ZEND_PRE_DEC:
68502
509
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68503
20
        spec = 3431 | SPEC_RULE_RETVAL;
68504
489
      } else if (op1_info == MAY_BE_LONG) {
68505
38
        spec = 3433 | SPEC_RULE_RETVAL;
68506
38
      }
68507
509
      break;
68508
742
    case ZEND_POST_INC:
68509
742
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68510
68
        spec = 3435;
68511
674
      } else if (op1_info == MAY_BE_LONG) {
68512
6
        spec = 3436;
68513
6
      }
68514
742
      break;
68515
1.16k
    case ZEND_POST_DEC:
68516
1.16k
      if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68517
8
        spec = 3437;
68518
1.15k
      } else if (op1_info == MAY_BE_LONG) {
68519
87
        spec = 3438;
68520
87
      }
68521
1.16k
      break;
68522
13.1k
    case ZEND_JMP:
68523
13.1k
      if (OP_JMP_ADDR(op, op->op1) > op) {
68524
8.69k
        spec = 2585;
68525
8.69k
      }
68526
13.1k
      break;
68527
79.2k
    case ZEND_INIT_FCALL:
68528
79.2k
      if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) {
68529
61.4k
        spec = 2578;
68530
61.4k
      }
68531
79.2k
      break;
68532
20.4k
    case ZEND_RECV:
68533
20.4k
      if (op->op2.num == MAY_BE_ANY) {
68534
14.6k
        spec = 2579;
68535
14.6k
      }
68536
20.4k
      break;
68537
105k
    case ZEND_SEND_VAL:
68538
105k
      if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
68539
75.7k
        spec = 3489;
68540
75.7k
      }
68541
105k
      break;
68542
5.96k
    case ZEND_SEND_VAR_EX:
68543
5.96k
      if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
68544
1.23k
        spec = 3484 | SPEC_RULE_OP1;
68545
1.23k
      }
68546
5.96k
      break;
68547
2.65k
    case ZEND_FE_FETCH_R:
68548
2.65k
      if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
68549
553
        spec = 3491 | SPEC_RULE_RETVAL;
68550
553
      }
68551
2.65k
      break;
68552
7.99k
    case ZEND_FETCH_DIM_R:
68553
7.99k
      if (!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
68554
4.38k
        if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68555
88
          break;
68556
88
        }
68557
4.29k
        spec = 3454 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68558
4.29k
      }
68559
7.91k
      break;
68560
45.1k
    case ZEND_SEND_VAL_EX:
68561
45.1k
      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))) {
68562
34.8k
        spec = 3490;
68563
34.8k
      }
68564
45.1k
      break;
68565
34.5k
    case ZEND_SEND_VAR:
68566
34.5k
      if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
68567
15.8k
        spec = 3479 | SPEC_RULE_OP1;
68568
15.8k
      }
68569
34.5k
      break;
68570
536
    case ZEND_COUNT:
68571
536
      if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
68572
196
        spec = 2580 | SPEC_RULE_OP1;
68573
196
      }
68574
536
      break;
68575
1.28k
    case ZEND_BW_OR:
68576
5.74k
    case ZEND_BW_AND:
68577
8.54k
    case ZEND_BW_XOR:
68578
8.97k
    case ZEND_BOOL_XOR:
68579
8.97k
      if (op->op1_type < op->op2_type) {
68580
341
        zend_swap_operands(op);
68581
341
      }
68582
8.97k
      break;
68583
0
    case ZEND_USER_OPCODE:
68584
0
      if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
68585
0
        if (op->op1_type < op->op2_type) {
68586
0
          zend_swap_operands(op);
68587
0
        }
68588
0
      }
68589
0
      break;
68590
1.39M
    default:
68591
1.39M
      break;
68592
1.79M
  }
68593
1.79M
  op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(spec, op)];
68594
1.79M
}
68595
68596
ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex)
68597
0
{
68598
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68599
  opcode_handler_t handler;
68600
#endif
68601
0
  DCL_OPLINE;
68602
0
  int ret;
68603
#ifdef ZEND_VM_IP_GLOBAL_REG
68604
  const zend_op *orig_opline = opline;
68605
#endif
68606
#ifdef ZEND_VM_FP_GLOBAL_REG
68607
  zend_execute_data *orig_execute_data = execute_data;
68608
  execute_data = ex;
68609
#else
68610
0
  zend_execute_data *execute_data = ex;
68611
0
#endif
68612
68613
0
  LOAD_OPLINE();
68614
#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
68615
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68616
  handler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[opline->opcode], opline);
68617
  handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68618
  if (EXPECTED(opline != &hybrid_halt_op)) {
68619
#else
68620
  ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68621
  if (EXPECTED(opline)) {
68622
#endif
68623
    ret = execute_data != ex ? (int)(execute_data->prev_execute_data != ex) + 1 : 0;
68624
    SAVE_OPLINE();
68625
  } else {
68626
    ret = -1;
68627
  }
68628
#else
68629
0
  opline = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68630
0
if (UNEXPECTED(((uintptr_t)opline & ZEND_VM_ENTER_BIT))) {
68631
0
    opline = (const zend_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT);
68632
0
    if (EXPECTED(opline)) {
68633
      /* ZEND_VM_ENTER() or ZEND_VM_LEAVE() */
68634
0
      ret = EG(current_execute_data) != ex ? (int)(EG(current_execute_data)->prev_execute_data != ex) + 1 : 0;
68635
0
      execute_data = EG(current_execute_data);
68636
0
      SAVE_OPLINE();
68637
0
    } else {
68638
      /* ZEND_VM_RETURN() */
68639
0
      ret = -1;
68640
0
    }
68641
0
  } else {
68642
    /* ZEND_VM_CONTINUE() */
68643
0
    SAVE_OPLINE();
68644
0
    ret = 0;
68645
0
  }
68646
0
#endif
68647
#ifdef ZEND_VM_FP_GLOBAL_REG
68648
  execute_data = orig_execute_data;
68649
#endif
68650
#ifdef ZEND_VM_IP_GLOBAL_REG
68651
  opline = orig_opline;
68652
#endif
68653
0
  return ret;
68654
0
}
68655